@tamagui/animations-reanimated 2.7.7 → 3.0.0-beta.1097.1

package/dist/cjs/createAnimations.native.cjs

@@ -0,0 +1,1176 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createAnimations_exports = {};
+__export(createAnimations_exports, { createAnimations: () => createAnimations });
+module.exports = __toCommonJS(createAnimations_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_animation_helpers = require("@tamagui/animation-helpers");
+var import_core = require("@tamagui/core");
+var import_internal_runtime = require("@tamagui/web/internal-runtime");
+var import_use_presence = require("@tamagui/use-presence");
+var import_normalize_colors = __toESM(require("@react-native/normalize-colors"), 1);
+var import_react = __toESM(require("react"), 1);
+var import_react_native_reanimated = __toESM(require("react-native-reanimated"), 1);
+var getDefaultExport = function(module2) {
+	var mod = module2;
+	if (mod.__esModule || mod[Symbol.toStringTag] === "Module") {
+		return mod.default || mod;
+	}
+	return mod;
+};
+var Animated = getDefaultExport(import_react_native_reanimated.default);
+var silenceAnimatedComponentDevCheck = function(style) {
+	if (process.env.NODE_ENV !== "development" || import_core.isWeb || !style || typeof style !== "object") {
+		return;
+	}
+	Object.defineProperty(style, "_requiresAnimatedComponent", {
+		configurable: true,
+		enumerable: false,
+		value: true
+	});
+};
+var resolveDynamicValue = function(value, isDark) {
+	if (value !== null && typeof value === "object" && "dynamic" in value && typeof value.dynamic === "object") {
+		var dynamic = value.dynamic;
+		return isDark ? dynamic.dark : dynamic.light;
+	}
+	return value;
+};
+var updateMapperState = import_core.isWeb ? function(state, emitted) {
+	state.value.emitted = emitted;
+} : function(state, emitted) {
+	"worklet";
+	if (!globalThis._WORKLET) return;
+	state.modify(function(current) {
+		current.emitted = emitted;
+		return current;
+	}, false);
+};
+var cloneAnimationValue = function(value) {
+	if (Array.isArray(value)) {
+		return value.map(cloneAnimationValue);
+	}
+	if (value && typeof value === "object") {
+		var next = {};
+		for (var key in value) {
+			next[key] = cloneAnimationValue(value[key]);
+		}
+		return next;
+	}
+	return value;
+};
+var cloneStyleRecord = function(style) {
+	var next = {};
+	for (var key in style) {
+		next[key] = cloneAnimationValue(style[key]);
+	}
+	return next;
+};
+var cloneTransitionConfig = function(config) {
+	return cloneAnimationValue(config);
+};
+var getAnimatedTransforms = function(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter(function(item) {
+		return item !== null && typeof item === "object" && !Array.isArray(item);
+	});
+};
+var getRemovedAnimatedKeys = function(current, previous) {
+	var removedKeys = {};
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = previous[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var key = _step.value;
+			if (!current.has(key)) removedKeys[key] = true;
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return removedKeys;
+};
+var getImplicitDefault = function(key, targetValue) {
+	"worklet";
+	var value = key === "opacity" || key === "scale" || key === "scaleX" || key === "scaleY" ? 1 : 0;
+	if (typeof targetValue !== "string") return value;
+	var suffixIndex = 0;
+	while (suffixIndex < targetValue.length) {
+		var character = targetValue[suffixIndex];
+		var code = character.charCodeAt(0);
+		if (code >= 48 && code <= 57 || character === "." || character === "-" || character === "+") {
+			suffixIndex++;
+		} else {
+			break;
+		}
+	}
+	return suffixIndex > 0 ? `${value}${targetValue.slice(suffixIndex)}` : value;
+};
+var COLOR_STYLE_KEYS = {
+	backgroundColor: true,
+	borderColor: true,
+	borderLeftColor: true,
+	borderRightColor: true,
+	borderTopColor: true,
+	borderBottomColor: true,
+	color: true
+};
+var toReanimatedColor = function(value) {
+	"worklet";
+	if (typeof value === "number") {
+		var color = value >>> 0;
+		var alpha = (color >>> 24 & 255) / 255;
+		var red = color >>> 16 & 255;
+		var green = color >>> 8 & 255;
+		var blue = color & 255;
+		return `rgba(${red}, ${green}, ${blue}, ${alpha})`;
+	}
+	if (typeof value !== "string") return value;
+	var trimmed = value.trim();
+	if (trimmed === "transparent") return "rgba(0, 0, 0, 0)";
+	return trimmed;
+};
+var isReanimatedColorHistory = function(value) {
+	"worklet";
+	var normalized = toReanimatedColor(value);
+	return typeof normalized === "string" && normalized.startsWith("rgba(");
+};
+var normalizeAnimationColor = function(value) {
+	if (typeof value === "number") {
+		return toReanimatedColor(value);
+	}
+	if (typeof value !== "string") return;
+	var color = (0, import_normalize_colors.default)(value);
+	if (color == null) return;
+	var red = Math.round((color & 4278190080) >>> 24);
+	var green = Math.round((color & 16711680) >>> 16);
+	var blue = Math.round((color & 65280) >>> 8);
+	var alpha = (color & 255) / 255;
+	return `rgba(${red}, ${green}, ${blue}, ${alpha})`;
+};
+var buildSnapshot = function(animated, statics, transforms, previousKeys, lastPainted) {
+	var snapshotAnimated = {};
+	var snapshotStatics = cloneStyleRecord(statics);
+	for (var key in snapshotStatics) {
+		if (!COLOR_STYLE_KEYS[key]) continue;
+		var normalized = normalizeAnimationColor(snapshotStatics[key]);
+		if (normalized !== void 0) snapshotStatics[key] = normalized;
+	}
+	for (var key1 in animated) {
+		if (key1 === "transform") continue;
+		var value = animated[key1];
+		if (COLOR_STYLE_KEYS[key1]) {
+			var normalized1 = normalizeAnimationColor(value);
+			if (normalized1 === void 0) {
+				snapshotStatics[key1] = cloneAnimationValue(value);
+				continue;
+			}
+			snapshotAnimated[key1] = normalized1;
+		} else {
+			snapshotAnimated[key1] = cloneAnimationValue(value);
+		}
+	}
+	var snapshotTransforms = transforms.map(cloneStyleRecord);
+	var keys = new Set(Object.keys(snapshotAnimated));
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = snapshotTransforms[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var transform = _step.value;
+			var key2 = Object.keys(transform)[0];
+			var value1 = key2 ? transform[key2] : void 0;
+			if (key2 && (typeof value1 === "number" || typeof value1 === "string")) {
+				keys.add(`transform:${key2}`);
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	var seeds = {};
+	var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+	try {
+		for (var _iterator1 = keys[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+			var key3 = _step1.value;
+			var value2 = lastPainted[key3];
+			if (typeof value2 !== "number" && typeof value2 !== "string") continue;
+			if (value2 === "auto" || typeof value2 === "string" && value2.startsWith("calc")) {
+				continue;
+			}
+			if (COLOR_STYLE_KEYS[key3]) value2 = normalizeAnimationColor(value2);
+			if (value2 !== void 0) seeds[key3] = value2;
+		}
+	} catch (err) {
+		_didIteratorError1 = true;
+		_iteratorError1 = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+				_iterator1.return();
+			}
+		} finally {
+			if (_didIteratorError1) {
+				throw _iteratorError1;
+			}
+		}
+	}
+	var gatedKeys = {};
+	var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+	try {
+		for (var _iterator2 = keys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+			var key4 = _step2.value;
+			gatedKeys[key4] = true;
+		}
+	} catch (err) {
+		_didIteratorError2 = true;
+		_iteratorError2 = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+				_iterator2.return();
+			}
+		} finally {
+			if (_didIteratorError2) {
+				throw _iteratorError2;
+			}
+		}
+	}
+	var removedKeys = getRemovedAnimatedKeys(keys, previousKeys);
+	var painted = {
+		...snapshotStatics,
+		...snapshotAnimated
+	};
+	var staticTransforms = getAnimatedTransforms(snapshotStatics.transform);
+	delete painted.transform;
+	var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = void 0;
+	try {
+		for (var _iterator3 = staticTransforms[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+			var transform1 = _step3.value;
+			var key5 = Object.keys(transform1)[0];
+			if (key5) painted[`transform:${key5}`] = transform1[key5];
+		}
+	} catch (err) {
+		_didIteratorError3 = true;
+		_iteratorError3 = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+				_iterator3.return();
+			}
+		} finally {
+			if (_didIteratorError3) {
+				throw _iteratorError3;
+			}
+		}
+	}
+	var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = void 0;
+	try {
+		for (var _iterator4 = snapshotTransforms[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+			var transform2 = _step4.value;
+			var key6 = Object.keys(transform2)[0];
+			if (key6) painted[`transform:${key6}`] = transform2[key6];
+		}
+	} catch (err) {
+		_didIteratorError4 = true;
+		_iteratorError4 = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+				_iterator4.return();
+			}
+		} finally {
+			if (_didIteratorError4) {
+				throw _iteratorError4;
+			}
+		}
+	}
+	return {
+		value: {
+			animated: snapshotAnimated,
+			statics: snapshotStatics,
+			transforms: snapshotTransforms,
+			gatedKeys,
+			seeds,
+			removedKeys,
+			removeTransform: Object.keys(removedKeys).some(function(key7) {
+				return key7.startsWith("transform:");
+			}),
+			clearValue: import_core.isWeb ? "" : null
+		},
+		painted,
+		keys
+	};
+};
+var getGatedKeys = function(snapshot) {
+	return Object.keys(snapshot.gatedKeys);
+};
+var createReanimatedConfig = function(config) {
+	"worklet";
+	var next = {};
+	var source = config;
+	for (var key in source) {
+		if (key === "type" || key === "delay") continue;
+		var value = source[key];
+		if (value !== void 0) {
+			next[key] = value;
+		}
+	}
+	return next;
+};
+var applyAnimation = function(targetValue, config, callback, seedValue) {
+	"worklet";
+	var validateStartAsColor = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : false;
+	var delay = config.delay;
+	var reanimatedConfig = createReanimatedConfig(config);
+	var animatedValue;
+	if (config.type === "timing") {
+		animatedValue = (0, import_react_native_reanimated.withTiming)(targetValue, reanimatedConfig, callback);
+	} else {
+		animatedValue = (0, import_react_native_reanimated.withSpring)(targetValue, reanimatedConfig, callback);
+		var innerOnFrame = animatedValue.onFrame;
+		animatedValue.onFrame = function(animation, now) {
+			"worklet";
+			return innerOnFrame(animation, now < animation.lastTimestamp ? animation.lastTimestamp : now);
+		};
+	}
+	var isAnimationDescriptor = animatedValue !== null && typeof animatedValue !== "number" && typeof animatedValue !== "string" && typeof animatedValue !== "boolean" && typeof animatedValue !== "undefined";
+	if (isAnimationDescriptor && (seedValue !== void 0 || validateStartAsColor)) {
+		var innerOnStart = animatedValue.onStart;
+		animatedValue.onStart = function(animation, value, timestamp, previousAnimation) {
+			"worklet";
+			var startValue = validateStartAsColor ? isReanimatedColorHistory(value) ? toReanimatedColor(value) : seedValue !== null && seedValue !== void 0 ? seedValue : targetValue : seedValue;
+			innerOnStart(animation, startValue, timestamp, previousAnimation);
+		};
+	}
+	if (isAnimationDescriptor && delay && delay > 0) {
+		animatedValue = (0, import_react_native_reanimated.withDelay)(delay, animatedValue);
+	}
+	return animatedValue;
+};
+var animateSnapshotValue = function(key, implicitKey, targetValue, config, previouslyEmitted, seedValue, gated, currentlyExiting, exitCycleId, currentlyCompletingEnter, enterCycleId, currentlyCompletingUpdate, updateCycleId, markExitKeyDone, markEnterKeyDone, markUpdateKeyDone) {
+	"worklet";
+	var validateStartAsColor = arguments.length > 16 && arguments[16] !== void 0 ? arguments[16] : false;
+	var cycleGated = gated && (currentlyExiting || currentlyCompletingEnter || currentlyCompletingUpdate);
+	if (!previouslyEmitted && seedValue === void 0 && !cycleGated) {
+		return targetValue;
+	}
+	var callback;
+	if (gated && currentlyExiting) {
+		callback = function(finished) {
+			"worklet";
+			(0, import_react_native_reanimated.runOnJS)(markExitKeyDone)(key, exitCycleId, finished !== null && finished !== void 0 ? finished : false);
+		};
+	} else if (gated && currentlyCompletingEnter) {
+		callback = function() {
+			"worklet";
+			(0, import_react_native_reanimated.runOnJS)(markEnterKeyDone)(key, enterCycleId);
+		};
+	} else if (gated && currentlyCompletingUpdate) {
+		callback = function(finished) {
+			"worklet";
+			(0, import_react_native_reanimated.runOnJS)(markUpdateKeyDone)(key, updateCycleId, finished !== null && finished !== void 0 ? finished : false);
+		};
+	}
+	return applyAnimation(targetValue, config, callback, previouslyEmitted ? void 0 : seedValue !== null && seedValue !== void 0 ? seedValue : getImplicitDefault(implicitKey, targetValue), validateStartAsColor);
+};
+var ANIMATABLE_PROPERTIES = {
+	transform: true,
+	opacity: true,
+	height: true,
+	width: true,
+	minWidth: true,
+	minHeight: true,
+	maxWidth: true,
+	maxHeight: true,
+	backgroundColor: true,
+	borderColor: true,
+	borderLeftColor: true,
+	borderRightColor: true,
+	borderTopColor: true,
+	borderBottomColor: true,
+	borderRadius: true,
+	borderTopLeftRadius: true,
+	borderTopRightRadius: true,
+	borderBottomLeftRadius: true,
+	borderBottomRightRadius: true,
+	borderWidth: true,
+	borderLeftWidth: true,
+	borderRightWidth: true,
+	borderTopWidth: true,
+	borderBottomWidth: true,
+	color: true,
+	fontSize: true,
+	fontWeight: true,
+	lineHeight: true,
+	letterSpacing: true,
+	left: true,
+	right: true,
+	top: true,
+	bottom: true,
+	margin: true,
+	marginTop: true,
+	marginBottom: true,
+	marginLeft: true,
+	marginRight: true,
+	marginHorizontal: true,
+	marginVertical: true,
+	padding: true,
+	paddingTop: true,
+	paddingBottom: true,
+	paddingLeft: true,
+	paddingRight: true,
+	paddingHorizontal: true,
+	paddingVertical: true,
+	gap: true,
+	rowGap: true,
+	columnGap: true,
+	flex: true,
+	flexGrow: true,
+	flexShrink: true
+};
+var canAnimateProperty = function(key, value) {
+	if (!ANIMATABLE_PROPERTIES[key]) return false;
+	if (value === "auto") return false;
+	if (typeof value === "string" && value.startsWith("calc")) return false;
+	return true;
+};
+var splitAnimationStyles = function(style, isDark, disableAnimation) {
+	var animated = {};
+	var statics = {};
+	for (var key in style) {
+		var value = resolveDynamicValue(style[key], isDark);
+		if (value === void 0) continue;
+		if (!disableAnimation && canAnimateProperty(key, value)) {
+			animated[key] = cloneAnimationValue(value);
+		} else {
+			statics[key] = cloneAnimationValue(value);
+		}
+	}
+	return {
+		animated,
+		statics
+	};
+};
+function createWebAnimatedComponent(defaultTag) {
+	var isText = defaultTag === "span";
+	var Component = Animated.createAnimatedComponent((0, import_core.createRefComponent)(function(propsIn, ref) {
+		var _hooks_usePropsTransform;
+		var { forwardedRef, render = defaultTag, ...rest } = propsIn;
+		var hostRef = (0, import_react.useRef)(null);
+		var composedRefs = (0, import_core.useComposedRefs)(forwardedRef, ref, hostRef);
+		var stateRef = (0, import_react.useRef)({ get host() {
+			return hostRef.current;
+		} });
+		var [, themeState] = (0, import_internal_runtime.useThemeWithState)({});
+		var _themeState_theme, _themeState_name;
+		var result = (0, import_core.getSplitStyles)(rest, isText ? import_core.Text.staticConfig : import_core.View.staticConfig, (_themeState_theme = themeState === null || themeState === void 0 ? void 0 : themeState.theme) !== null && _themeState_theme !== void 0 ? _themeState_theme : {}, (_themeState_name = themeState === null || themeState === void 0 ? void 0 : themeState.name) !== null && _themeState_name !== void 0 ? _themeState_name : "", { unmounted: false }, {
+			isAnimated: false,
+			noClass: true
+		});
+		var _result_viewProps;
+		var viewProps = (_result_viewProps = result === null || result === void 0 ? void 0 : result.viewProps) !== null && _result_viewProps !== void 0 ? _result_viewProps : {};
+		var Element = render;
+		var transformedProps = (_hooks_usePropsTransform = import_core.hooks.usePropsTransform) === null || _hooks_usePropsTransform === void 0 ? void 0 : _hooks_usePropsTransform.call(import_core.hooks, render, viewProps, stateRef, false);
+		var { nativeID, ...webProps } = transformedProps !== null && transformedProps !== void 0 ? transformedProps : viewProps;
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Element, {
+			...webProps,
+			ref: composedRefs
+		});
+	}));
+	Component.acceptRenderProp = true;
+	return Component;
+}
+var AnimatedView = createWebAnimatedComponent("div");
+var AnimatedText = createWebAnimatedComponent("span");
+var defaultConfig = { type: "spring" };
+function entryToReanimated(entry) {
+	if (entry.timing.kind === "spring") {
+		return {
+			type: "spring",
+			stiffness: entry.timing.stiffness,
+			damping: entry.timing.damping,
+			mass: entry.timing.mass,
+			delay: entry.delayMs || void 0
+		};
+	}
+	var bezier = (0, import_animation_helpers.easingToBezier)(entry.timing.easing);
+	return {
+		type: "timing",
+		duration: entry.timing.durationMs,
+		easing: bezier ? import_react_native_reanimated.Easing.bezier(bezier[0], bezier[1], bezier[2], bezier[3]) : void 0,
+		delay: entry.delayMs || void 0
+	};
+}
+function buildTransitionConfig(transition, animations, animationState, styleKeys) {
+	var resolved = (0, import_animation_helpers.forAnimationState)((0, import_animation_helpers.resolveTransition)(transition, { animations }), animationState);
+	var base = resolved.all ? entryToReanimated(resolved.all) : { ...defaultConfig };
+	var propertyConfigs = {};
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = styleKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var key = _step.value;
+			var entry = (0, import_animation_helpers.getTransitionForKey)(resolved, key);
+			propertyConfigs[key] = entry ? entryToReanimated(entry) : instantConfig();
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return {
+		baseConfig: base,
+		propertyConfigs,
+		resolved
+	};
+}
+var instantConfig = function() {
+	return {
+		type: "timing",
+		duration: 0
+	};
+};
+function getStyleKeys(style) {
+	var keys = new Set(Object.keys(style));
+	if (style.transform && Array.isArray(style.transform)) {
+		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+		try {
+			for (var _iterator = style.transform[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+				var t = _step.value;
+				if (t && typeof t === "object") {
+					keys.add(Object.keys(t)[0]);
+				}
+			}
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion && _iterator.return != null) {
+					_iterator.return();
+				}
+			} finally {
+				if (_didIteratorError) {
+					throw _iteratorError;
+				}
+			}
+		}
+	}
+	return keys;
+}
+function createAnimations(animations) {
+	return {
+		needsCustomComponent: true,
+		View: import_core.isWeb ? AnimatedView : Animated.View,
+		Text: import_core.isWeb ? AnimatedText : Animated.Text,
+		inputStyle: "value",
+		outputStyle: "inline",
+		avoidReRenders: true,
+		animations,
+		usePresence: import_use_presence.usePresence,
+		ResetPresence: import_use_presence.ResetPresence,
+		useAnimatedNumber(initial) {
+			var sharedValue = (0, import_react_native_reanimated.useSharedValue)(initial);
+			return (0, import_react.useMemo)(function() {
+				return {
+					getInstance() {
+						"worklet";
+						return sharedValue;
+					},
+					getValue() {
+						"worklet";
+						return sharedValue.value;
+					},
+					setValue(next) {
+						var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : { type: "spring" }, onFinish = arguments.length > 2 ? arguments[2] : void 0;
+						if (config.type === "direct") {
+							sharedValue.value = next;
+							onFinish === null || onFinish === void 0 ? void 0 : onFinish();
+						} else {
+							var cb = onFinish ? function(finished) {
+								"worklet";
+								if (finished !== false) {
+									(0, import_react_native_reanimated.runOnJS)(onFinish)();
+								}
+							} : void 0;
+							var animationConfig = cloneTransitionConfig(config);
+							if (import_core.isWeb) {
+								sharedValue.value = applyAnimation(next, animationConfig, cb);
+							} else {
+								(0, import_react_native_reanimated.runOnUI)(function(targetValue, animationConfig2) {
+									"worklet";
+									sharedValue.value = applyAnimation(targetValue, animationConfig2, cb);
+								})(next, animationConfig);
+							}
+						}
+					},
+					stop() {
+						(0, import_react_native_reanimated.cancelAnimation)(sharedValue);
+					}
+				};
+			}, [sharedValue]);
+		},
+		useAnimatedNumberReaction(param, onValue) {
+			var { value } = param;
+			var instance = value.getInstance();
+			return (0, import_react_native_reanimated.useAnimatedReaction)(function() {
+				return instance.value;
+			}, function(next, prev) {
+				if (prev !== next) {
+					(0, import_react_native_reanimated.runOnJS)(onValue)(next);
+				}
+			}, [onValue, instance]);
+		},
+		useAnimatedNumberStyle(val, getStyle) {
+			var instance = val.getInstance();
+			if (import_core.isWeb) {
+				return (0, import_react_native_reanimated.useAnimatedStyle)(function() {
+					"worklet";
+					return getStyle(instance.value);
+				}, [instance, getStyle]);
+			}
+			var styleVal = (0, import_react_native_reanimated.useDerivedValue)(function() {
+				"worklet";
+				return getStyle(instance.value);
+			});
+			var animatedStyle = (0, import_react_native_reanimated.useAnimatedStyle)(function() {
+				"worklet";
+				return styleVal.value;
+			});
+			silenceAnimatedComponentDevCheck(animatedStyle);
+			return animatedStyle;
+		},
+		useAnimatedNumbersStyle(vals, getStyle) {
+			var instances = vals.map(function(v) {
+				return v.getInstance();
+			});
+			var animatedStyle = (0, import_react_native_reanimated.useAnimatedStyle)(function() {
+				"worklet";
+				var currentValues = instances.map(function(inst) {
+					return inst.value;
+				});
+				return getStyle(...currentValues);
+			}, import_core.isWeb ? [getStyle, ...instances] : void 0);
+			silenceAnimatedComponentDevCheck(animatedStyle);
+			return animatedStyle;
+		},
+		useAnimations(animationProps) {
+			var { props, presence, style, componentState, useStyleEmitter, themeName, stateRef, styleState, onTransition } = animationProps;
+			var isHydrating = componentState.unmounted === true;
+			var isMounting = componentState.unmounted === "should-enter";
+			var isEntering = !!componentState.unmounted;
+			var isExiting = (presence === null || presence === void 0 ? void 0 : presence[0]) === false;
+			var wasEnteringRef = (0, import_react.useRef)(isEntering);
+			var justFinishedEntering = wasEnteringRef.current && !isEntering;
+			import_react.default.useEffect(function() {
+				wasEnteringRef.current = isEntering;
+			});
+			var _styleState_effectiveTransition;
+			var effectiveTransition = (_styleState_effectiveTransition = styleState === null || styleState === void 0 ? void 0 : styleState.effectiveTransition) !== null && _styleState_effectiveTransition !== void 0 ? _styleState_effectiveTransition : props.transition;
+			var animationState = isExiting ? "exit" : isMounting || justFinishedEntering ? "enter" : "default";
+			var resolvedTransition = (0, import_animation_helpers.forAnimationState)((0, import_animation_helpers.resolveTransition)(effectiveTransition, { animations }), animationState);
+			var disableAnimation = isHydrating || !(0, import_animation_helpers.hasTransition)(resolvedTransition);
+			var isDark = (themeName === null || themeName === void 0 ? void 0 : themeName.startsWith("dark")) || false;
+			var sendExitComplete = presence === null || presence === void 0 ? void 0 : presence[1];
+			var onTransitionRef = (0, import_react.useRef)(onTransition);
+			onTransitionRef.current = onTransition;
+			var emit = function(phase, cause, finished) {
+				var _onTransitionRef_current;
+				(_onTransitionRef_current = onTransitionRef.current) === null || _onTransitionRef_current === void 0 ? void 0 : _onTransitionRef_current.call(onTransitionRef, phase === "end" ? {
+					phase,
+					cause,
+					finished
+				} : {
+					phase,
+					cause
+				});
+			};
+			var enterStartedRef = (0, import_react.useRef)(false);
+			var exitStartedRef = (0, import_react.useRef)(false);
+			var updateStartedRef = (0, import_react.useRef)(false);
+			var isExitingJSRef = (0, import_react.useRef)(false);
+			isExitingJSRef.current = isExiting;
+			var updateCycleIdRef = (0, import_react.useRef)(0);
+			var pendingUpdateKeysRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+			var updateCompletedRef = (0, import_react.useRef)(false);
+			var isCompletingUpdateRef = (0, import_react_native_reanimated.useSharedValue)(false);
+			var updateCycleIdShared = (0, import_react_native_reanimated.useSharedValue)(0);
+			var updateInterruptedRef = (0, import_react.useRef)(false);
+			var markUpdateKeyDone = (0, import_core.useEvent)(function(key, cycleId, finished) {
+				if (cycleId !== updateCycleIdRef.current) return;
+				if (updateCompletedRef.current) return;
+				if (!finished) updateInterruptedRef.current = true;
+				pendingUpdateKeysRef.current.delete(key);
+				if (pendingUpdateKeysRef.current.size === 0) {
+					updateCompletedRef.current = true;
+					isCompletingUpdateRef.value = false;
+					if (updateStartedRef.current) {
+						updateStartedRef.current = false;
+						emit("end", "update", !updateInterruptedRef.current);
+					}
+				}
+			});
+			var exitCycleIdRef = (0, import_react.useRef)(0);
+			var pendingExitKeysRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+			var exitCompletedRef = (0, import_react.useRef)(false);
+			var wasExitingRef = (0, import_react.useRef)(false);
+			var justStartedExiting = isExiting && !wasExitingRef.current;
+			var justStoppedExiting = !isExiting && wasExitingRef.current;
+			var markExitKeyDone = (0, import_core.useEvent)(function(key, cycleId, finished) {
+				if (cycleId !== exitCycleIdRef.current) return;
+				if (exitCompletedRef.current) return;
+				pendingExitKeysRef.current.delete(key);
+				if (pendingExitKeysRef.current.size === 0) {
+					exitCompletedRef.current = true;
+					if (exitStartedRef.current) {
+						exitStartedRef.current = false;
+						emit("end", "exit", true);
+					}
+					sendExitComplete === null || sendExitComplete === void 0 ? void 0 : sendExitComplete();
+				}
+			});
+			var enterCycleIdRef = (0, import_react.useRef)(0);
+			var pendingEnterKeysRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+			var enterCompletedRef = (0, import_react.useRef)(false);
+			var markEnterKeyDone = (0, import_core.useEvent)(function(key, cycleId) {
+				if (cycleId !== enterCycleIdRef.current) return;
+				if (enterCompletedRef.current) return;
+				if (isExitingJSRef.current) return;
+				pendingEnterKeysRef.current.delete(key);
+				if (pendingEnterKeysRef.current.size === 0) {
+					enterCompletedRef.current = true;
+					if (enterStartedRef.current) {
+						enterStartedRef.current = false;
+						emit("end", "enter", true);
+					}
+				}
+			});
+			var isExitingRef = (0, import_react_native_reanimated.useSharedValue)(isExiting);
+			var exitCycleIdShared = (0, import_react_native_reanimated.useSharedValue)(exitCycleIdRef.current);
+			var isCompletingEnterRef = (0, import_react_native_reanimated.useSharedValue)(false);
+			var enterCycleIdShared = (0, import_react_native_reanimated.useSharedValue)(enterCycleIdRef.current);
+			if (justStartedExiting) {
+				exitCycleIdRef.current++;
+				exitCompletedRef.current = false;
+				pendingExitKeysRef.current.clear();
+				enterCycleIdRef.current++;
+				pendingEnterKeysRef.current.clear();
+				updateCycleIdRef.current++;
+				pendingUpdateKeysRef.current.clear();
+				updateCompletedRef.current = true;
+			}
+			if (justStoppedExiting) {
+				exitCycleIdRef.current++;
+				pendingExitKeysRef.current.clear();
+			}
+			(0, import_core.useIsomorphicLayoutEffect)(function() {
+				isExitingRef.value = isExiting;
+				exitCycleIdShared.value = exitCycleIdRef.current;
+				isCompletingEnterRef.value = !isExiting && justFinishedEntering && Boolean(onTransitionRef.current);
+				enterCycleIdShared.value = enterCycleIdRef.current;
+				if (justStartedExiting) {
+					isCompletingUpdateRef.value = false;
+					updateCycleIdShared.value = updateCycleIdRef.current;
+				}
+			}, [
+				isExiting,
+				justFinishedEntering,
+				exitCycleIdRef.current,
+				enterCycleIdRef.current,
+				justStartedExiting
+			]);
+			(0, import_core.useIsomorphicLayoutEffect)(function() {
+				if (justStoppedExiting && exitStartedRef.current && !exitCompletedRef.current) {
+					exitStartedRef.current = false;
+					emit("end", "exit", false);
+				}
+			}, [justStoppedExiting]);
+			import_react.default.useEffect(function() {
+				wasExitingRef.current = isExiting;
+			});
+			var committedRenderKeysRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+			var lastPaintedRef = (0, import_react.useRef)({});
+			var carryRef = (0, import_react.useRef)({});
+			var { animatedStyles, staticStyles, nextCarry } = (0, import_react.useMemo)(function() {
+				var { animated, statics } = splitAnimationStyles(style, isDark, disableAnimation);
+				var nextCarry2 = cloneStyleRecord(carryRef.current);
+				for (var key in nextCarry2) {
+					if (!(key in animated)) delete nextCarry2[key];
+				}
+				for (var key1 in animated) {
+					if (!(key1 in nextCarry2)) {
+						nextCarry2[key1] = cloneAnimationValue(animated[key1]);
+					}
+					statics[key1] = nextCarry2[key1];
+				}
+				return {
+					animatedStyles: animated,
+					staticStyles: statics,
+					nextCarry: nextCarry2
+				};
+			}, [
+				disableAnimation,
+				style,
+				isDark
+			]);
+			var renderSnapshot = (0, import_react.useMemo)(function() {
+				return buildSnapshot(animatedStyles, staticStyles, getAnimatedTransforms(animatedStyles.transform), committedRenderKeysRef.current, lastPaintedRef.current);
+			}, [animatedStyles, staticStyles]);
+			var renderSnapshotRef = (0, import_react_native_reanimated.useSharedValue)({
+				animated: {},
+				statics: {},
+				transforms: [],
+				gatedKeys: {},
+				seeds: {},
+				removedKeys: {},
+				removeTransform: false,
+				clearValue: import_core.isWeb ? "" : null
+			});
+			var emitterSnapshotRef = (0, import_react_native_reanimated.useSharedValue)(null);
+			var emitterKeysRef = (0, import_react.useRef)(null);
+			(0, import_core.useIsomorphicLayoutEffect)(function() {
+				carryRef.current = nextCarry;
+				committedRenderKeysRef.current = renderSnapshot.keys;
+				lastPaintedRef.current = renderSnapshot.painted;
+			}, [nextCarry, renderSnapshot]);
+			var pseudoActiveRef = (0, import_react.useRef)(false);
+			var publishedSnapshotRef = (0, import_react.useRef)(null);
+			(0, import_core.useIsomorphicLayoutEffect)(function() {
+				var renderChanged = publishedSnapshotRef.current !== renderSnapshot.value;
+				var droppingLatch = (isExiting || !pseudoActiveRef.current && publishedSnapshotRef.current !== null && renderChanged) && emitterSnapshotRef.value !== null;
+				var emitterKeys = droppingLatch ? emitterKeysRef.current : null;
+				if (droppingLatch || renderChanged) {
+					var removedKeys = emitterKeys ? {
+						...renderSnapshot.value.removedKeys,
+						...getRemovedAnimatedKeys(renderSnapshot.keys, emitterKeys)
+					} : renderSnapshot.value.removedKeys;
+					renderSnapshotRef.value = {
+						...renderSnapshot.value,
+						removedKeys,
+						removeTransform: Object.keys(removedKeys).some(function(key) {
+							return key.startsWith("transform:");
+						})
+					};
+					publishedSnapshotRef.current = renderSnapshot.value;
+				}
+				if (droppingLatch) {
+					emitterSnapshotRef.value = null;
+					emitterKeysRef.current = null;
+				}
+			});
+			var { baseConfig, propertyConfigs } = (0, import_react.useMemo)(function() {
+				if (isHydrating) {
+					return {
+						baseConfig: {
+							type: "timing",
+							duration: 0
+						},
+						propertyConfigs: {}
+					};
+				}
+				return buildTransitionConfig(effectiveTransition, animations, animationState, getStyleKeys(animatedStyles));
+			}, [
+				isHydrating,
+				effectiveTransition,
+				animatedStyles,
+				animationState
+			]);
+			var configRef = (0, import_react_native_reanimated.useSharedValue)({
+				baseConfig,
+				propertyConfigs,
+				disableAnimation,
+				isHydrating
+			});
+			(0, import_core.useIsomorphicLayoutEffect)(function() {
+				configRef.value = {
+					baseConfig,
+					propertyConfigs,
+					disableAnimation,
+					isHydrating
+				};
+			}, [
+				baseConfig,
+				propertyConfigs,
+				disableAnimation,
+				isHydrating
+			]);
+			useStyleEmitter === null || useStyleEmitter === void 0 ? void 0 : useStyleEmitter(function(nextStyle, effectiveTransition2, pseudoActive) {
+				if (isExitingJSRef.current) return;
+				pseudoActiveRef.current = pseudoActive === true;
+				var transitionToUse = effectiveTransition2 !== null && effectiveTransition2 !== void 0 ? effectiveTransition2 : props.transition;
+				var { baseConfig: newBase, propertyConfigs: newPropertyConfigs } = buildTransitionConfig(transitionToUse, animations, animationState, getStyleKeys(nextStyle));
+				configRef.value = {
+					baseConfig: newBase,
+					propertyConfigs: newPropertyConfigs,
+					disableAnimation: configRef.value.disableAnimation,
+					isHydrating: configRef.value.isHydrating
+				};
+				var _emitterKeysRef_current;
+				var previousKeys = (_emitterKeysRef_current = emitterKeysRef.current) !== null && _emitterKeysRef_current !== void 0 ? _emitterKeysRef_current : committedRenderKeysRef.current;
+				var { animated, statics } = splitAnimationStyles(nextStyle, isDark, configRef.value.disableAnimation);
+				var snapshot = buildSnapshot(animated, statics, getAnimatedTransforms(animated.transform), previousKeys, lastPaintedRef.current);
+				emitterSnapshotRef.value = snapshot.value;
+				emitterKeysRef.current = snapshot.keys;
+				lastPaintedRef.current = snapshot.painted;
+				if (process.env.NODE_ENV === "development" && props.debug && props.debug !== "profile") {
+					console.info("[animations-reanimated] useStyleEmitter update", {
+						animated,
+						statics,
+						transforms: snapshot.value.transforms
+					});
+				}
+			});
+			var exitKeysRegistered = (0, import_react.useRef)(false);
+			var enterKeysRegistered = (0, import_react.useRef)(false);
+			if (!isExiting && justFinishedEntering && onTransition) {
+				var enterKeys = getGatedKeys(renderSnapshot.value);
+				enterCycleIdRef.current++;
+				enterCompletedRef.current = false;
+				pendingEnterKeysRef.current = new Set(enterKeys);
+				enterKeysRegistered.current = enterKeys.length > 0;
+			}
+			if (justStartedExiting && sendExitComplete) {
+				var exitKeys = getGatedKeys(renderSnapshot.value);
+				pendingExitKeysRef.current = new Set(exitKeys);
+				exitKeysRegistered.current = exitKeys.length > 0;
+			}
+			var previousUpdateStyleRef = (0, import_react.useRef)(null);
+			var updateStyle = onTransition ? JSON.stringify(style) : null;
+			var previousUpdateStyle = previousUpdateStyleRef.current;
+			var shouldRegisterUpdate = updateStyle !== null && previousUpdateStyle !== null && previousUpdateStyle !== updateStyle && !isExiting && !isEntering && !justFinishedEntering;
+			var updateKeys = shouldRegisterUpdate ? getGatedKeys(renderSnapshot.value) : [];
+			(0, import_core.useIsomorphicLayoutEffect)(function() {
+				if (updateStyle === null) {
+					previousUpdateStyleRef.current = null;
+					isCompletingUpdateRef.value = false;
+					return;
+				}
+				var previousStyleStillCurrent = previousUpdateStyleRef.current === previousUpdateStyle;
+				previousUpdateStyleRef.current = updateStyle;
+				if (!shouldRegisterUpdate || !previousStyleStillCurrent) return;
+				var cycleId = ++updateCycleIdRef.current;
+				pendingUpdateKeysRef.current = new Set(updateKeys);
+				updateInterruptedRef.current = false;
+				updateCompletedRef.current = updateKeys.length === 0;
+				isCompletingUpdateRef.value = updateKeys.length > 0;
+				updateCycleIdShared.value = cycleId;
+				if (updateStartedRef.current) {
+					emit("end", "update", false);
+				}
+				updateStartedRef.current = true;
+				emit("start", "update");
+				if (updateKeys.length === 0) {
+					updateStartedRef.current = false;
+					emit("end", "update", true);
+				}
+			}, [updateStyle, shouldRegisterUpdate]);
+			import_react.default.useEffect(function() {
+				if (!justStartedExiting || !sendExitComplete) return;
+				if (enterStartedRef.current) {
+					enterStartedRef.current = false;
+					emit("end", "enter", false);
+				}
+				if (updateStartedRef.current) {
+					updateStartedRef.current = false;
+					emit("end", "update", false);
+				}
+				if (onTransitionRef.current && !exitStartedRef.current) {
+					exitStartedRef.current = true;
+					emit("start", "exit");
+				}
+				if (!exitKeysRegistered.current && pendingExitKeysRef.current.size === 0) {
+					if (!exitCompletedRef.current) {
+						exitCompletedRef.current = true;
+						if (exitStartedRef.current) {
+							exitStartedRef.current = false;
+							emit("end", "exit", true);
+						}
+						sendExitComplete();
+					}
+				}
+			}, [justStartedExiting, sendExitComplete]);
+			import_react.default.useEffect(function() {
+				if (isExiting || !justFinishedEntering || !onTransition) return;
+				if (!enterStartedRef.current) {
+					enterStartedRef.current = true;
+					emit("start", "enter");
+				}
+				if (!enterKeysRegistered.current && pendingEnterKeysRef.current.size === 0) {
+					if (!enterCompletedRef.current) {
+						enterCompletedRef.current = true;
+						if (enterStartedRef.current) {
+							enterStartedRef.current = false;
+							emit("end", "enter", true);
+						}
+					}
+				}
+			}, [
+				isExiting,
+				justFinishedEntering,
+				onTransition
+			]);
+			var mapperStateRef = (0, import_react_native_reanimated.useSharedValue)({ emitted: {} });
+			var animatedStyle = (0, import_react_native_reanimated.useAnimatedStyle)(function() {
+				"worklet";
+				var mapperState = mapperStateRef.value;
+				var config = configRef.value;
+				if (config.disableAnimation || config.isHydrating) {
+					updateMapperState(mapperStateRef, {});
+					return {};
+				}
+				var previouslyEmitted = mapperState.emitted;
+				var emitted = {};
+				var result = {};
+				var emitterSnapshot = emitterSnapshotRef.value;
+				var snapshot = emitterSnapshot !== null && emitterSnapshot !== void 0 ? emitterSnapshot : renderSnapshotRef.value;
+				var animatedValues = snapshot.animated;
+				var staticValues = snapshot.statics;
+				var currentlyExiting = isExitingRef.value;
+				var currentCycleId = exitCycleIdShared.value;
+				var currentlyCompletingEnter = isCompletingEnterRef.value;
+				var currentEnterCycleId = enterCycleIdShared.value;
+				var currentlyCompletingUpdate = isCompletingUpdateRef.value;
+				var currentUpdateCycleId = updateCycleIdShared.value;
+				for (var key in staticValues) {
+					result[key] = staticValues[key];
+				}
+				for (var key1 in snapshot.removedKeys) {
+					if (!key1.startsWith("transform:") && !(key1 in staticValues)) {
+						result[key1] = snapshot.clearValue;
+					}
+				}
+				for (var key2 in animatedValues) {
+					if (key2 === "transform") continue;
+					var targetValue = animatedValues[key2];
+					emitted[key2] = true;
+					if (typeof targetValue !== "number" && typeof targetValue !== "string") {
+						result[key2] = targetValue;
+						continue;
+					}
+					var _config_propertyConfigs_key;
+					result[key2] = animateSnapshotValue(key2, key2, targetValue, (_config_propertyConfigs_key = config.propertyConfigs[key2]) !== null && _config_propertyConfigs_key !== void 0 ? _config_propertyConfigs_key : config.baseConfig, !!previouslyEmitted[key2], snapshot.seeds[key2], !!snapshot.gatedKeys[key2], currentlyExiting, currentCycleId, currentlyCompletingEnter, currentEnterCycleId, currentlyCompletingUpdate, currentUpdateCycleId, markExitKeyDone, markEnterKeyDone, markUpdateKeyDone, !!COLOR_STYLE_KEYS[key2]);
+				}
+				var transforms = snapshot.transforms;
+				if (transforms.length > 0 || snapshot.removeTransform) {
+					var validTransforms = [];
+					var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+					try {
+						for (var _iterator = transforms[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+							var t = _step.value;
+							if (!t) continue;
+							var keys = Object.keys(t);
+							if (keys.length === 0) continue;
+							var transformKey = keys[0];
+							var value = t[transformKey];
+							if (typeof value === "number" || typeof value === "string") {
+								var _config_propertyConfigs_transformKey;
+								var propConfig = (_config_propertyConfigs_transformKey = config.propertyConfigs[transformKey]) !== null && _config_propertyConfigs_transformKey !== void 0 ? _config_propertyConfigs_transformKey : config.baseConfig;
+								var subKey = `transform:${transformKey}`;
+								emitted[subKey] = true;
+								validTransforms.push({ [transformKey]: animateSnapshotValue(subKey, transformKey, value, propConfig, !!previouslyEmitted[subKey], snapshot.seeds[subKey], !!snapshot.gatedKeys[subKey], currentlyExiting, currentCycleId, currentlyCompletingEnter, currentEnterCycleId, currentlyCompletingUpdate, currentUpdateCycleId, markExitKeyDone, markEnterKeyDone, markUpdateKeyDone) });
+							} else {
+								validTransforms.push(t);
+							}
+						}
+					} catch (err) {
+						_didIteratorError = true;
+						_iteratorError = err;
+					} finally {
+						try {
+							if (!_iteratorNormalCompletion && _iterator.return != null) {
+								_iterator.return();
+							}
+						} finally {
+							if (_didIteratorError) {
+								throw _iteratorError;
+							}
+						}
+					}
+					if (validTransforms.length > 0 || !("transform" in staticValues)) {
+						result.transform = validTransforms;
+					}
+				}
+				updateMapperState(mapperStateRef, emitted);
+				return result;
+			}, import_core.isWeb ? [
+				renderSnapshotRef,
+				emitterSnapshotRef,
+				configRef,
+				isExitingRef,
+				exitCycleIdShared,
+				markExitKeyDone,
+				isCompletingEnterRef,
+				enterCycleIdShared,
+				markEnterKeyDone,
+				isCompletingUpdateRef,
+				updateCycleIdShared,
+				markUpdateKeyDone
+			] : void 0);
+			silenceAnimatedComponentDevCheck(animatedStyle);
+			if (process.env.NODE_ENV === "development" && props.debug && props.debug !== "profile") {
+				console.info("[animations-reanimated] useAnimations", {
+					resolvedTransition,
+					componentState,
+					isExiting,
+					animatedStyles,
+					staticStyles,
+					baseConfig,
+					propertyConfigs
+				});
+			}
+			return { style: [staticStyles, animatedStyle] };
+		}
+	};
+}