@granite-js/vitest 1.0.20

package/dist/reactNativeRuntime.js

@@ -0,0 +1,1711 @@
+import { n as REACT_NATIVE_ASSET_MODULE_ID_PATTERN } from "./assets-DoucBOz0.js";
+import { n as installNativeModuleProxy, r as installReactNativeGlobals, t as defineGlobalProperty } from "./runtimeBootstrap-CHWitCG1.js";
+import Module, { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import "@react-native/js-polyfills/error-guard";
+import { vi } from "vitest";
+
+//#region src/reactNativeRuntime.ts
+const runtimeGlobals = globalThis;
+const runtimeDirectory = path.dirname(fileURLToPath(import.meta.url));
+const runtimeRequire = createRequire(import.meta.url);
+function resolveReactNativeMirrorRoot() {
+	if (typeof globalThis.__GRANITE_VITEST_RN_CACHE_ROOT__ === "string" && globalThis.__GRANITE_VITEST_RN_CACHE_ROOT__.length > 0) return path.resolve(globalThis.__GRANITE_VITEST_RN_CACHE_ROOT__);
+	throw new Error("[@granite-js/vitest] reactNativeRuntime requires reactNative() in vitest.config to set __GRANITE_VITEST_RN_CACHE_ROOT__.");
+}
+const reactNativeMirrorRoot = resolveReactNativeMirrorRoot();
+let nextNativeTag = 1;
+function createMockNativeMethods() {
+	return {
+		blur: vi.fn(),
+		focus: vi.fn(),
+		measure: vi.fn(),
+		measureInWindow: vi.fn(),
+		measureLayout: vi.fn(),
+		setNativeProps: vi.fn()
+	};
+}
+function createMockHostComponent(React, displayName, hostType, instanceMethods = {}, realComponent) {
+	const resolvedRealComponent = realComponent ?? null;
+	const superClass = typeof resolvedRealComponent === "function" && (resolvedRealComponent.prototype instanceof React.Component || resolvedRealComponent.prototype?.isReactComponent != null) ? resolvedRealComponent : React.Component;
+	const resolvedName = resolvedRealComponent?.displayName || resolvedRealComponent?.name || resolvedRealComponent?.render?.displayName || resolvedRealComponent?.render?.name || displayName;
+	const resolvedHostType = hostType || resolvedName.replace(/^(RCT|RK)/, "");
+	class Component extends superClass {
+		render() {
+			const sourceProps = this.props;
+			const props = { ...resolvedRealComponent?.defaultProps ?? {} };
+			Object.keys(sourceProps).forEach((propName) => {
+				if (sourceProps[propName] !== void 0) props[propName] = sourceProps[propName];
+			});
+			return React.createElement(resolvedHostType, props, props.children);
+		}
+	}
+	if (resolvedRealComponent != null) Object.keys(resolvedRealComponent).forEach((classStatic) => {
+		Component[classStatic] = resolvedRealComponent[classStatic];
+	});
+	Object.assign(Component.prototype, instanceMethods);
+	Object.defineProperty(Component, "name", {
+		configurable: true,
+		enumerable: false,
+		value: resolvedName,
+		writable: false
+	});
+	Object.defineProperty(Component, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: resolvedHostType,
+		writable: true
+	});
+	return Component;
+}
+function createMockNativeComponent(React, viewName) {
+	const hostName = viewName === "RCTView" ? "View" : viewName;
+	class Component extends React.Component {
+		_nativeTag = nextNativeTag++;
+		render() {
+			const props = this.props;
+			return React.createElement(hostName, props, props.children);
+		}
+	}
+	Object.assign(Component.prototype, createMockNativeMethods());
+	Object.defineProperty(Component, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: hostName,
+		writable: true
+	});
+	return Component;
+}
+function createAccessibilityInfoMockModule() {
+	return {
+		__esModule: true,
+		default: {
+			addEventListener: vi.fn(() => ({ remove: vi.fn() })),
+			announceForAccessibility: vi.fn(),
+			announceForAccessibilityWithOptions: vi.fn(),
+			getRecommendedTimeoutMillis: vi.fn(() => Promise.resolve(false)),
+			isAccessibilityServiceEnabled: vi.fn(() => Promise.resolve(false)),
+			isBoldTextEnabled: vi.fn(() => Promise.resolve(false)),
+			isDarkerSystemColorsEnabled: vi.fn(() => Promise.resolve(false)),
+			isGrayscaleEnabled: vi.fn(() => Promise.resolve(false)),
+			isHighTextContrastEnabled: vi.fn(() => Promise.resolve(false)),
+			isInvertColorsEnabled: vi.fn(() => Promise.resolve(false)),
+			isReduceMotionEnabled: vi.fn(() => Promise.resolve(false)),
+			isReduceTransparencyEnabled: vi.fn(() => Promise.resolve(false)),
+			isScreenReaderEnabled: vi.fn(() => Promise.resolve(false)),
+			prefersCrossFadeTransitions: vi.fn(() => Promise.resolve(false)),
+			sendAccessibilityEvent: vi.fn(),
+			setAccessibilityFocus: vi.fn()
+		}
+	};
+}
+function createClipboardMockModule() {
+	return {
+		__esModule: true,
+		default: {
+			getString: vi.fn(() => ""),
+			setString: vi.fn()
+		}
+	};
+}
+function createRefreshControlMockModule() {
+	const React = runtimeRequire("react");
+	const RCTRefreshControl = createMockNativeComponent(React, "RCTRefreshControl");
+	class RefreshControlMock extends React.Component {
+		static latestRef;
+		componentDidMount() {
+			RefreshControlMock.latestRef = this;
+		}
+		render() {
+			return React.createElement(RCTRefreshControl);
+		}
+	}
+	return {
+		__esModule: true,
+		default: RefreshControlMock
+	};
+}
+function createActivityIndicatorMockModule() {
+	return {
+		__esModule: true,
+		default: createMockHostComponent(runtimeRequire("react"), "ActivityIndicator", "ActivityIndicator")
+	};
+}
+function createImageMockModule() {
+	return {
+		__esModule: true,
+		default: createMockHostComponent(runtimeRequire("react"), "Image", "Image")
+	};
+}
+function createTextMockModule() {
+	return {
+		__esModule: true,
+		default: createMockHostComponent(runtimeRequire("react"), "Text", "Text", createMockNativeMethods())
+	};
+}
+function createTextInputMockModule() {
+	return {
+		__esModule: true,
+		default: createMockHostComponent(runtimeRequire("react"), "TextInput", "TextInput", {
+			...createMockNativeMethods(),
+			clear: vi.fn(),
+			getNativeRef: vi.fn(function getNativeRef() {
+				return this;
+			}),
+			isFocused: vi.fn(() => false)
+		})
+	};
+}
+function createModalMockModule() {
+	const React = runtimeRequire("react");
+	const BaseComponent = createMockHostComponent(React, "Modal", "Modal");
+	class ModalMock extends BaseComponent {
+		render() {
+			const props = this.props;
+			if (props.visible === false) return null;
+			return React.createElement(BaseComponent, props, props.children);
+		}
+	}
+	Object.defineProperty(ModalMock, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "Modal",
+		writable: true
+	});
+	return {
+		__esModule: true,
+		default: ModalMock
+	};
+}
+function createViewMockModule() {
+	return {
+		__esModule: true,
+		default: createMockHostComponent(runtimeRequire("react"), "View", "View", createMockNativeMethods())
+	};
+}
+function createScrollViewMockModule(sharedView) {
+	const React = runtimeRequire("react");
+	const BaseComponent = createMockHostComponent(React, "ScrollView", "ScrollView", {
+		...createMockNativeMethods(),
+		flashScrollIndicators: vi.fn(),
+		getInnerViewNode: vi.fn(),
+		getInnerViewRef: vi.fn(),
+		getNativeScrollRef: vi.fn(),
+		getScrollResponder: vi.fn(),
+		getScrollableNode: vi.fn(),
+		scrollResponderScrollNativeHandleToKeyboard: vi.fn(),
+		scrollResponderZoomTo: vi.fn(),
+		scrollTo: vi.fn(),
+		scrollToEnd: vi.fn()
+	});
+	const View = sharedView ?? createViewMockModule().default;
+	const RCTScrollView = createMockNativeComponent(React, "RCTScrollView");
+	class ScrollViewMock extends BaseComponent {
+		render() {
+			const props = this.props;
+			return React.createElement(RCTScrollView, props, props.refreshControl, React.createElement(View, null, props.children));
+		}
+	}
+	Object.defineProperty(ScrollViewMock, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "ScrollView",
+		writable: true
+	});
+	return {
+		__esModule: true,
+		default: ScrollViewMock
+	};
+}
+function createAppStateMockModule() {
+	return {
+		__esModule: true,
+		default: {
+			addEventListener: vi.fn(() => ({ remove: vi.fn() })),
+			currentState: "active",
+			removeEventListener: vi.fn()
+		}
+	};
+}
+function createLinkingMockModule() {
+	return {
+		__esModule: true,
+		default: {
+			addEventListener: vi.fn(() => ({ remove: vi.fn() })),
+			canOpenURL: vi.fn(() => Promise.resolve(true)),
+			getInitialURL: vi.fn(() => Promise.resolve()),
+			openSettings: vi.fn(),
+			openURL: vi.fn(),
+			sendIntent: vi.fn()
+		}
+	};
+}
+function createVibrationMockModule() {
+	return {
+		__esModule: true,
+		default: {
+			cancel: vi.fn(),
+			vibrate: vi.fn()
+		}
+	};
+}
+function createViewNativeComponentMockModule() {
+	return {
+		__esModule: true,
+		default: createMockHostComponent(runtimeRequire("react"), "View", "View")
+	};
+}
+function createUseColorSchemeMockModule() {
+	return {
+		__esModule: true,
+		default: vi.fn().mockReturnValue("light")
+	};
+}
+function createPlatformMockModule() {
+	const platformConstants = runtimeGlobals.nativeModuleProxy?.PlatformConstants?.getConstants?.() ?? {
+		forceTouchAvailable: false,
+		interfaceIdiom: "phone",
+		isDisableAnimations: false,
+		isMacCatalyst: false,
+		isTesting: true,
+		osVersion: "17.0",
+		reactNativeVersion: {
+			major: 0,
+			minor: 79,
+			patch: 5,
+			prerelease: void 0
+		},
+		systemName: "iOS"
+	};
+	const platform = {
+		OS: "ios",
+		select: (spec) => "ios" in spec ? spec.ios : "native" in spec ? spec.native : spec.default,
+		get Version() {
+			return platformConstants.osVersion;
+		},
+		get constants() {
+			return platformConstants;
+		},
+		get isPad() {
+			return platformConstants.interfaceIdiom === "pad";
+		},
+		get isTV() {
+			return platformConstants.interfaceIdiom === "tv";
+		},
+		get isVision() {
+			return platformConstants.interfaceIdiom === "vision";
+		},
+		get isTesting() {
+			return runtimeGlobals.__DEV__ ? platformConstants.isTesting : false;
+		},
+		get isDisableAnimations() {
+			return platformConstants.isDisableAnimations ?? platform.isTesting;
+		},
+		get isMacCatalyst() {
+			return platformConstants.isMacCatalyst ?? false;
+		}
+	};
+	return {
+		__esModule: true,
+		default: platform
+	};
+}
+function createStyleSheetMockModule() {
+	const styleSheet = {
+		absoluteFill: {
+			bottom: 0,
+			left: 0,
+			position: "absolute",
+			right: 0,
+			top: 0
+		},
+		absoluteFillObject: {
+			bottom: 0,
+			left: 0,
+			position: "absolute",
+			right: 0,
+			top: 0
+		},
+		compose: vi.fn((left, right) => {
+			if (left == null) return right;
+			if (right == null) return left;
+			return [left, right];
+		}),
+		create: vi.fn((styles) => styles),
+		flatten: vi.fn((style) => {
+			if (!Array.isArray(style)) return style ?? {};
+			return style.filter(Boolean).reduce((accumulator, value) => {
+				if (typeof value === "object" && value != null && !Array.isArray(value)) Object.assign(accumulator, value);
+				return accumulator;
+			}, {});
+		}),
+		hairlineWidth: 1,
+		setStyleAttributePreprocessor: vi.fn()
+	};
+	return {
+		__esModule: true,
+		...styleSheet,
+		default: styleSheet
+	};
+}
+function createInitializeCoreMockModule() {
+	return {
+		__esModule: true,
+		default: {}
+	};
+}
+function createNativeExceptionsManagerMockModule() {
+	const nativeExceptionsManager = {
+		dismissRedbox: vi.fn(),
+		reportException: vi.fn(),
+		updateExceptionMessage: vi.fn()
+	};
+	return {
+		__esModule: true,
+		default: nativeExceptionsManager,
+		...nativeExceptionsManager
+	};
+}
+function createRendererProxyMockModule() {
+	const rendererProxy = {
+		dispatchCommand: vi.fn(),
+		findHostInstance_DEPRECATED: vi.fn((component) => component ?? null),
+		findNodeHandle: vi.fn((component) => {
+			if (component == null) return null;
+			return component._nativeTag ?? 1;
+		}),
+		getNodeFromInternalInstanceHandle: vi.fn((handle) => handle ?? null),
+		getPublicInstanceFromInternalInstanceHandle: vi.fn((handle) => handle ?? null),
+		getPublicInstanceFromRootTag: vi.fn((rootTag) => rootTag ?? null),
+		isChildPublicInstance: vi.fn(() => false),
+		isProfilingRenderer: vi.fn(() => false),
+		renderElement: vi.fn(),
+		sendAccessibilityEvent: vi.fn(),
+		unstable_batchedUpdates: vi.fn((callback, ...args) => callback(...args)),
+		unmountComponentAtNodeAndRemoveContainer: vi.fn()
+	};
+	return {
+		__esModule: true,
+		...rendererProxy,
+		default: rendererProxy
+	};
+}
+function createUIManagerMockModule() {
+	return {
+		__esModule: true,
+		default: runtimeGlobals.nativeModuleProxy?.UIManager ?? {}
+	};
+}
+function createNativeModulesMockModule() {
+	return {
+		__esModule: true,
+		default: runtimeGlobals.nativeModuleProxy ?? {}
+	};
+}
+function createNativeComponentRegistryMockModule() {
+	const registry = {
+		get: vi.fn((name) => createMockNativeComponent(runtimeRequire("react"), name)),
+		getWithFallback_DEPRECATED: vi.fn((name) => createMockNativeComponent(runtimeRequire("react"), name)),
+		setRuntimeConfigProvider: vi.fn(),
+		unstable_hasStaticViewConfig: vi.fn(() => false)
+	};
+	return {
+		__esModule: true,
+		...registry,
+		default: registry
+	};
+}
+function createRequireNativeComponentMockModule() {
+	return {
+		__esModule: true,
+		default: vi.fn((name) => createMockNativeComponent(runtimeRequire("react"), name))
+	};
+}
+function createCodegenNativeComponentMockModule() {
+	return {
+		__esModule: true,
+		default: vi.fn((componentName, options) => {
+			const { requireNativeComponentModule, uiManagerModule } = getSharedReactNativeMockModules();
+			const requireNativeComponent = requireNativeComponentModule.default ?? requireNativeComponentModule;
+			const uiManager = uiManagerModule.default ?? uiManagerModule;
+			let componentNameInUse = options?.paperComponentName != null ? options.paperComponentName : componentName;
+			if (options?.paperComponentNameDeprecated != null && typeof uiManager?.hasViewManagerConfig === "function") {
+				if (uiManager.hasViewManagerConfig(componentName)) componentNameInUse = componentName;
+				else if (uiManager.hasViewManagerConfig(options.paperComponentNameDeprecated)) componentNameInUse = options.paperComponentNameDeprecated;
+			}
+			return requireNativeComponent(componentNameInUse);
+		})
+	};
+}
+function createCodegenNativeCommandsMockModule() {
+	return {
+		__esModule: true,
+		default: vi.fn((options) => {
+			const { rendererProxyModule } = getSharedReactNativeMockModules();
+			const rendererProxy = rendererProxyModule.default ?? rendererProxyModule;
+			const commandObject = {};
+			for (const command of options.supportedCommands ?? []) commandObject[command] = vi.fn((ref, ...args) => {
+				rendererProxy.dispatchCommand(ref, command, args);
+			});
+			return commandObject;
+		})
+	};
+}
+let sharedReactNativeMockModules = null;
+let sharedReactNativeExports = null;
+function getSharedReactNativeMockModules() {
+	if (sharedReactNativeMockModules != null) return sharedReactNativeMockModules;
+	const viewModule = createViewMockModule();
+	sharedReactNativeMockModules = {
+		accessibilityInfoModule: createAccessibilityInfoMockModule(),
+		activityIndicatorModule: createActivityIndicatorMockModule(),
+		appStateModule: createAppStateMockModule(),
+		clipboardModule: createClipboardMockModule(),
+		codegenNativeCommandsModule: createCodegenNativeCommandsMockModule(),
+		codegenNativeComponentModule: createCodegenNativeComponentMockModule(),
+		imageModule: createImageMockModule(),
+		initializeCoreModule: createInitializeCoreMockModule(),
+		linkingModule: createLinkingMockModule(),
+		modalModule: createModalMockModule(),
+		nativeComponentRegistryModule: createNativeComponentRegistryMockModule(),
+		nativeExceptionsManagerModule: createNativeExceptionsManagerMockModule(),
+		nativeModulesModule: createNativeModulesMockModule(),
+		platformModule: createPlatformMockModule(),
+		refreshControlModule: createRefreshControlMockModule(),
+		rendererProxyModule: createRendererProxyMockModule(),
+		requireNativeComponentModule: createRequireNativeComponentMockModule(),
+		scrollViewModule: createScrollViewMockModule(viewModule.default),
+		styleSheetModule: createStyleSheetMockModule(),
+		textInputModule: createTextInputMockModule(),
+		textModule: createTextMockModule(),
+		uiManagerModule: createUIManagerMockModule(),
+		useColorSchemeModule: createUseColorSchemeMockModule(),
+		vibrationModule: createVibrationMockModule(),
+		viewModule,
+		viewNativeComponentModule: createViewNativeComponentMockModule()
+	};
+	return sharedReactNativeMockModules;
+}
+function getSharedReactNativeExports() {
+	if (sharedReactNativeExports != null) return sharedReactNativeExports;
+	const React = runtimeRequire("react");
+	const { accessibilityInfoModule, activityIndicatorModule, appStateModule, clipboardModule, codegenNativeCommandsModule, codegenNativeComponentModule, imageModule, linkingModule, modalModule, nativeComponentRegistryModule, nativeModulesModule, platformModule, refreshControlModule, rendererProxyModule, requireNativeComponentModule, scrollViewModule, styleSheetModule, textInputModule, textModule, uiManagerModule, useColorSchemeModule, vibrationModule, viewModule, viewNativeComponentModule } = getSharedReactNativeMockModules();
+	let dimensionsState = runtimeGlobals.nativeModuleProxy?.DeviceInfo?.getConstants?.().Dimensions ?? {
+		screen: {
+			fontScale: 2,
+			height: 1334,
+			scale: 2,
+			width: 750
+		},
+		window: {
+			fontScale: 2,
+			height: 1334,
+			scale: 2,
+			width: 750
+		}
+	};
+	const dimensionListeners = /* @__PURE__ */ new Set();
+	const Dimensions = {
+		addEventListener: vi.fn((type, handler) => {
+			if (type === "change") dimensionListeners.add(handler);
+			return { remove: () => dimensionListeners.delete(handler) };
+		}),
+		get: vi.fn((name) => dimensionsState[name]),
+		set: vi.fn((nextDimensions) => {
+			dimensionsState = {
+				...dimensionsState,
+				...nextDimensions
+			};
+			dimensionListeners.forEach((listener) => listener(dimensionsState));
+		})
+	};
+	const useWindowDimensions = () => Dimensions.get("window");
+	const createEventEmitter = () => {
+		const listeners = /* @__PURE__ */ new Map();
+		return {
+			addListener: vi.fn((eventType, listener) => {
+				const eventListeners = listeners.get(eventType) ?? /* @__PURE__ */ new Set();
+				eventListeners.add(listener);
+				listeners.set(eventType, eventListeners);
+				return { remove: () => eventListeners.delete(listener) };
+			}),
+			emit: vi.fn((eventType, ...args) => {
+				listeners.get(eventType)?.forEach((listener) => listener(...args));
+			}),
+			removeAllListeners: vi.fn((eventType) => {
+				if (eventType == null) {
+					listeners.clear();
+					return;
+				}
+				listeners.delete(eventType);
+			}),
+			listenerCount: vi.fn((eventType) => listeners.get(eventType)?.size ?? 0)
+		};
+	};
+	const DeviceInfo = runtimeGlobals.nativeModuleProxy?.DeviceInfo ?? { getConstants: vi.fn(() => ({ Dimensions: dimensionsState })) };
+	const DevSettings = {
+		...runtimeGlobals.nativeModuleProxy?.DevSettings ?? {},
+		addMenuItem: vi.fn(),
+		onFastRefresh: vi.fn(),
+		reload: vi.fn()
+	};
+	const i18nConstants = runtimeGlobals.nativeModuleProxy?.I18nManager?.getConstants?.() ?? {
+		doLeftAndRightSwapInRTL: true,
+		isRTL: false,
+		localeIdentifier: "en_US"
+	};
+	const I18nManager = {
+		allowRTL: vi.fn((shouldAllow) => runtimeGlobals.nativeModuleProxy?.I18nManager?.allowRTL?.(shouldAllow)),
+		doLeftAndRightSwapInRTL: i18nConstants.doLeftAndRightSwapInRTL,
+		forceRTL: vi.fn((shouldForce) => runtimeGlobals.nativeModuleProxy?.I18nManager?.forceRTL?.(shouldForce)),
+		getConstants: vi.fn(() => i18nConstants),
+		isRTL: i18nConstants.isRTL,
+		swapLeftAndRightInRTL: vi.fn((shouldSwap) => runtimeGlobals.nativeModuleProxy?.I18nManager?.swapLeftAndRightInRTL?.(shouldSwap))
+	};
+	const PlatformColor = (...names) => ({ semantic: names });
+	const processColor = vi.fn((color) => color);
+	const turboModuleLookup = (name) => runtimeGlobals.__turboModuleProxy?.(name) ?? runtimeGlobals.nativeModuleProxy?.[name] ?? null;
+	const TurboModuleRegistry = {
+		get: vi.fn((name) => turboModuleLookup(name)),
+		getEnforcing: vi.fn((name) => {
+			const module = turboModuleLookup(name);
+			if (module == null) throw new Error(`TurboModuleRegistry.getEnforcing(...): '${name}' could not be found.`);
+			return module;
+		})
+	};
+	const ActionSheetIOS = {
+		dismissActionSheet: vi.fn(),
+		showActionSheetWithOptions: vi.fn((_options, callback) => callback(0)),
+		showShareActionSheetWithOptions: vi.fn((_options, _failureCallback, successCallback) => successCallback(true, null))
+	};
+	const Alert = {
+		alert: vi.fn(),
+		prompt: vi.fn()
+	};
+	let appearanceColorScheme = "light";
+	const appearanceListeners = /* @__PURE__ */ new Set();
+	const Appearance = {
+		addChangeListener: vi.fn((listener) => {
+			appearanceListeners.add(listener);
+			return { remove: () => appearanceListeners.delete(listener) };
+		}),
+		getColorScheme: vi.fn(() => appearanceColorScheme),
+		setColorScheme: vi.fn((nextColorScheme) => {
+			appearanceColorScheme = nextColorScheme;
+			appearanceListeners.forEach((listener) => listener({ colorScheme: appearanceColorScheme }));
+		})
+	};
+	const backPressSubscriptions = /* @__PURE__ */ new Set();
+	const BackHandler = {
+		addEventListener: vi.fn((_eventName, handler) => {
+			backPressSubscriptions.add(handler);
+			return { remove: () => backPressSubscriptions.delete(handler) };
+		}),
+		exitApp: vi.fn()
+	};
+	const DeviceEventEmitter = createEventEmitter();
+	const NativeAppEventEmitter = DeviceEventEmitter;
+	const Keyboard = {
+		...createEventEmitter(),
+		dismiss: vi.fn(),
+		isVisible: vi.fn(() => false),
+		metrics: vi.fn(() => null),
+		scheduleLayoutAnimation: vi.fn()
+	};
+	const PixelRatio = {
+		get: vi.fn(() => Dimensions.get("window").scale),
+		getFontScale: vi.fn(() => Dimensions.get("window").fontScale || Dimensions.get("window").scale),
+		getPixelSizeForLayoutSize: vi.fn((layoutSize) => Math.round(layoutSize * Dimensions.get("window").scale)),
+		roundToNearestPixel: vi.fn((layoutSize) => {
+			const ratio = Dimensions.get("window").scale;
+			return Math.round(layoutSize * ratio) / ratio;
+		}),
+		startDetecting: vi.fn()
+	};
+	const settingsSubscriptions = [];
+	const Settings = {
+		_settings: {},
+		clearWatch: vi.fn((watchId) => {
+			if (watchId < settingsSubscriptions.length) settingsSubscriptions[watchId] = {
+				callback: null,
+				keys: []
+			};
+		}),
+		get: vi.fn((key) => Settings._settings[key]),
+		set: vi.fn((nextSettings) => {
+			Settings._settings = {
+				...Settings._settings,
+				...nextSettings
+			};
+			Object.keys(nextSettings).forEach((key) => {
+				settingsSubscriptions.forEach((subscription) => {
+					if (subscription.callback && subscription.keys.includes(key)) subscription.callback();
+				});
+			});
+		}),
+		watchKeys: vi.fn((keys, callback) => {
+			const normalizedKeys = Array.isArray(keys) ? keys : [keys];
+			const watchId = settingsSubscriptions.length;
+			settingsSubscriptions.push({
+				callback,
+				keys: normalizedKeys
+			});
+			return watchId;
+		})
+	};
+	const Share = {
+		dismissedAction: "dismissedAction",
+		share: vi.fn(async () => ({
+			action: "sharedAction",
+			activityType: null
+		})),
+		sharedAction: "sharedAction"
+	};
+	const callableModules = runtimeGlobals.__rntlCallableModules ?? {
+		callable: {},
+		lazy: {}
+	};
+	defineGlobalProperty(runtimeGlobals, "__rntlCallableModules", callableModules);
+	const registerCallableModule = vi.fn((name, moduleOrFactory) => {
+		if (runtimeGlobals.RN$Bridgeless === true && typeof runtimeGlobals.RN$registerCallableModule === "function") {
+			if (typeof moduleOrFactory === "function") {
+				runtimeGlobals.RN$registerCallableModule(name, moduleOrFactory);
+				return;
+			}
+			runtimeGlobals.RN$registerCallableModule(name, () => moduleOrFactory);
+			return;
+		}
+		if (typeof moduleOrFactory === "function") {
+			callableModules.lazy[name] = moduleOrFactory;
+			delete callableModules.callable[name];
+			return;
+		}
+		callableModules.callable[name] = moduleOrFactory;
+		delete callableModules.lazy[name];
+	});
+	const Button = ({ accessibilityState, disabled, title, ...props }) => React.createElement("View", {
+		...props,
+		accessibilityRole: "button",
+		accessibilityState: {
+			...accessibilityState ?? {},
+			disabled: Boolean(disabled)
+		},
+		accessible: props.accessible ?? true
+	}, React.createElement("Text", null, platformModule.default?.OS === "android" ? title.toUpperCase() : title));
+	Button.displayName = "Button";
+	class DrawerLayoutAndroid extends React.Component {
+		closeDrawer = vi.fn();
+		openDrawer = vi.fn();
+		render() {
+			const props = this.props;
+			return React.createElement("AndroidDrawerLayout", props, props.children);
+		}
+	}
+	Object.assign(DrawerLayoutAndroid.prototype, createMockNativeMethods());
+	Object.defineProperty(DrawerLayoutAndroid, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "DrawerLayoutAndroid",
+		writable: true
+	});
+	const createListSeparators = () => ({
+		highlight: vi.fn(),
+		unhighlight: vi.fn(),
+		updateProps: vi.fn()
+	});
+	const getItemKey = (item, index, keyExtractor) => keyExtractor?.(item, index) ?? item?.key ?? String(index);
+	class FlatList extends React.PureComponent {
+		flashScrollIndicators = vi.fn();
+		getNativeScrollRef = vi.fn(() => this.scrollViewRef);
+		getScrollResponder = vi.fn(() => this.scrollViewRef);
+		getScrollableNode = vi.fn(() => this.scrollViewRef);
+		recordInteraction = vi.fn();
+		scrollToEnd = vi.fn();
+		scrollToIndex = vi.fn();
+		scrollToItem = vi.fn();
+		scrollToOffset = vi.fn();
+		setNativeProps = vi.fn();
+		scrollViewRef = null;
+		setScrollViewRef = (ref) => {
+			this.scrollViewRef = ref;
+		};
+		render() {
+			const { data, keyExtractor, renderItem, ...props } = this.props;
+			const ScrollViewComponent = scrollViewModule.default ?? scrollViewModule;
+			const items = Array.isArray(data) ? data : [];
+			return React.createElement(ScrollViewComponent, {
+				...props,
+				ref: this.setScrollViewRef
+			}, items.map((item, index) => React.createElement(React.Fragment, { key: getItemKey(item, index, keyExtractor) }, renderItem?.({
+				index,
+				item,
+				separators: createListSeparators()
+			}))));
+		}
+	}
+	Object.defineProperty(FlatList, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "FlatList",
+		writable: true
+	});
+	class VirtualizedList extends React.PureComponent {
+		flashScrollIndicators = vi.fn();
+		getNativeScrollRef = vi.fn(() => this.scrollViewRef);
+		getScrollResponder = vi.fn(() => this.scrollViewRef);
+		getScrollableNode = vi.fn(() => this.scrollViewRef);
+		recordInteraction = vi.fn();
+		scrollToEnd = vi.fn();
+		scrollToIndex = vi.fn();
+		scrollToOffset = vi.fn();
+		setNativeProps = vi.fn();
+		scrollViewRef = null;
+		setScrollViewRef = (ref) => {
+			this.scrollViewRef = ref;
+		};
+		render() {
+			const { data, getItem, getItemCount, renderItem, ...props } = this.props;
+			const ScrollViewComponent = scrollViewModule.default ?? scrollViewModule;
+			const itemCount = getItemCount?.(data) ?? 0;
+			return React.createElement(ScrollViewComponent, {
+				...props,
+				ref: this.setScrollViewRef
+			}, Array.from({ length: itemCount }, (_, index) => {
+				const item = getItem?.(data, index);
+				return React.createElement(React.Fragment, { key: getItemKey(item, index) }, renderItem?.({
+					index,
+					item,
+					separators: createListSeparators()
+				}));
+			}));
+		}
+	}
+	Object.defineProperty(VirtualizedList, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "VirtualizedList",
+		writable: true
+	});
+	class ImageBackground extends React.Component {
+		viewRef = null;
+		setNativeProps = vi.fn((props) => {
+			this.viewRef?.setNativeProps?.(props);
+		});
+		captureViewRef = (ref) => {
+			this.viewRef = ref;
+		};
+		render() {
+			const { children, imageRef, imageStyle, style, ...props } = this.props;
+			const ViewComponent = viewModule.default ?? viewModule;
+			const ImageComponent = imageModule.default ?? imageModule;
+			return React.createElement(ViewComponent, {
+				accessibilityIgnoresInvertColors: true,
+				ref: this.captureViewRef,
+				style
+			}, React.createElement(ImageComponent, {
+				...props,
+				ref: imageRef,
+				style: imageStyle
+			}), children);
+		}
+	}
+	Object.defineProperty(ImageBackground, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "ImageBackground",
+		writable: true
+	});
+	const InputAccessoryView = ({ children, ...props }) => {
+		if (React.Children.count(children) === 0) return null;
+		return React.createElement("InputAccessoryView", props, children);
+	};
+	InputAccessoryView.displayName = "InputAccessoryView";
+	const LayoutConformance = createMockHostComponent(React, "LayoutConformance", "LayoutConformance");
+	const KeyboardAvoidingView = createMockHostComponent(React, "KeyboardAvoidingView", "KeyboardAvoidingView", createMockNativeMethods());
+	const ProgressBarAndroid = createMockHostComponent(React, "ProgressBarAndroid", "ProgressBarAndroid");
+	class StatusBar extends React.Component {
+		static currentHeight = runtimeGlobals.nativeModuleProxy?.StatusBarManager?.getConstants?.().HEIGHT ?? 0;
+		static setBackgroundColor = vi.fn((color, animated) => runtimeGlobals.nativeModuleProxy?.StatusBarManager?.setBackgroundColor?.(color, animated));
+		static setBarStyle = vi.fn((style, animated) => runtimeGlobals.nativeModuleProxy?.StatusBarManager?.setStyle?.(style, animated));
+		static setHidden = vi.fn((hidden, animation) => runtimeGlobals.nativeModuleProxy?.StatusBarManager?.setHidden?.(hidden, animation));
+		static setNetworkActivityIndicatorVisible = vi.fn((visible) => runtimeGlobals.nativeModuleProxy?.StatusBarManager?.setNetworkActivityIndicatorVisible?.(visible));
+		static setTranslucent = vi.fn((translucent) => runtimeGlobals.nativeModuleProxy?.StatusBarManager?.setTranslucent?.(translucent));
+		render() {
+			return null;
+		}
+	}
+	Object.defineProperty(StatusBar, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "StatusBar",
+		writable: true
+	});
+	const Switch = createMockHostComponent(React, "Switch", "Switch", createMockNativeMethods());
+	const createTouchableComponent = (displayName) => {
+		class TouchableComponent extends React.Component {
+			render() {
+				const props = {
+					...this.props,
+					accessible: this.props.accessible ?? true
+				};
+				return React.createElement("View", props, props.children);
+			}
+		}
+		Object.assign(TouchableComponent.prototype, createMockNativeMethods());
+		Object.defineProperty(TouchableComponent, "displayName", {
+			configurable: true,
+			enumerable: true,
+			value: displayName,
+			writable: true
+		});
+		return TouchableComponent;
+	};
+	const Touchable = createTouchableComponent("Touchable");
+	const TouchableHighlight = createTouchableComponent("TouchableHighlight");
+	const TouchableNativeFeedback = createTouchableComponent("TouchableNativeFeedback");
+	const TouchableOpacity = createTouchableComponent("TouchableOpacity");
+	const TouchableWithoutFeedback = createTouchableComponent("TouchableWithoutFeedback");
+	const appRegistryRunnables = {};
+	const appRegistrySections = {};
+	const AppRegistry = {
+		getAppKeys: vi.fn(() => Object.keys(appRegistryRunnables)),
+		getRegistry: vi.fn(() => ({
+			runnables: { ...appRegistryRunnables },
+			sections: Object.keys(appRegistrySections)
+		})),
+		getRunnable: vi.fn((appKey) => appRegistryRunnables[appKey]),
+		getSectionKeys: vi.fn(() => Object.keys(appRegistrySections)),
+		getSections: vi.fn(() => ({ ...appRegistrySections })),
+		registerComponent: vi.fn((appKey, componentProvider, section) => {
+			const runnable = vi.fn(() => componentProvider());
+			appRegistryRunnables[appKey] = runnable;
+			if (section) appRegistrySections[appKey] = runnable;
+			return appKey;
+		}),
+		registerConfig: vi.fn((configs) => {
+			configs.forEach((config) => {
+				if (typeof config.run === "function" && typeof config.appKey === "string") {
+					AppRegistry.registerRunnable(config.appKey, config.run);
+					return;
+				}
+				if (typeof config.appKey === "string" && typeof config.component === "function") AppRegistry.registerComponent(config.appKey, config.component, Boolean(config.section));
+			});
+		}),
+		registerRunnable: vi.fn((appKey, run) => {
+			appRegistryRunnables[appKey] = run;
+			return appKey;
+		}),
+		registerSection: vi.fn((appKey, componentProvider) => {
+			AppRegistry.registerComponent(appKey, componentProvider, true);
+		}),
+		setRootViewStyleProvider: vi.fn(),
+		setWrapperComponentProvider: vi.fn()
+	};
+	const Easing = {
+		back: vi.fn((s = 1.70158) => (t) => t * t * ((s + 1) * t - s)),
+		bezier: vi.fn(() => (t) => t),
+		bounce: vi.fn((t) => t * t),
+		circle: vi.fn((t) => 1 - Math.sqrt(1 - t * t)),
+		cubic: vi.fn((t) => t * t * t),
+		ease: vi.fn((t) => t * t * (3 - 2 * t)),
+		elastic: vi.fn((bounciness = 1) => (t) => 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * bounciness * Math.PI)),
+		exp: vi.fn((t) => Math.pow(2, 10 * (t - 1))),
+		in: vi.fn((easing) => (t) => easing(t)),
+		inOut: vi.fn((easing) => (t) => t < .5 ? easing(t * 2) / 2 : 1 - easing((1 - t) * 2) / 2),
+		linear: vi.fn((t) => t),
+		out: vi.fn((easing) => (t) => 1 - easing(1 - t)),
+		poly: vi.fn((n) => (t) => Math.pow(t, n)),
+		quad: vi.fn((t) => t * t),
+		sin: vi.fn((t) => 1 - Math.cos(t * Math.PI / 2)),
+		step0: vi.fn((n) => n > 0 ? 1 : 0),
+		step1: vi.fn((n) => n >= 1 ? 1 : 0)
+	};
+	const interactionEventEmitter = createEventEmitter();
+	let nextInteractionHandle = 1;
+	const InteractionManager = {
+		Events: {
+			interactionComplete: "interactionComplete",
+			interactionStart: "interactionStart"
+		},
+		addListener: interactionEventEmitter.addListener,
+		clearInteractionHandle: vi.fn(() => void 0),
+		createInteractionHandle: vi.fn(() => nextInteractionHandle++),
+		runAfterInteractions: vi.fn((task) => {
+			let cancelled = false;
+			const promise = Promise.resolve().then(() => {
+				if (cancelled) return;
+				if (typeof task === "function") {
+					task();
+					return;
+				}
+				task?.run?.();
+			});
+			return {
+				cancel: () => {
+					cancelled = true;
+				},
+				then: promise.then.bind(promise)
+			};
+		}),
+		setDeadline: vi.fn()
+	};
+	let layoutAnimationEnabled = true;
+	const layoutAnimationTypes = {
+		easeInEaseOut: "easeInEaseOut",
+		easeIn: "easeIn",
+		easeOut: "easeOut",
+		keyboard: "keyboard",
+		linear: "linear",
+		spring: "spring"
+	};
+	const layoutAnimationProperties = {
+		opacity: "opacity",
+		scaleX: "scaleX",
+		scaleXY: "scaleXY",
+		scaleY: "scaleY"
+	};
+	const createLayoutAnimationConfig = (duration, type, property) => ({
+		create: {
+			property,
+			type
+		},
+		delete: {
+			property,
+			type
+		},
+		duration,
+		update: { type }
+	});
+	const layoutAnimationPresets = {
+		easeInEaseOut: createLayoutAnimationConfig(300, "easeInEaseOut", "opacity"),
+		linear: createLayoutAnimationConfig(500, "linear", "opacity"),
+		spring: {
+			create: {
+				property: "opacity",
+				type: "linear"
+			},
+			delete: {
+				property: "opacity",
+				type: "linear"
+			},
+			duration: 700,
+			update: {
+				springDamping: .4,
+				type: "spring"
+			}
+		}
+	};
+	const LayoutAnimation = {
+		Properties: layoutAnimationProperties,
+		Presets: layoutAnimationPresets,
+		Types: layoutAnimationTypes,
+		checkConfig: vi.fn(),
+		configureNext: vi.fn((_config, onAnimationDidEnd, _onAnimationDidFail) => {
+			if (layoutAnimationEnabled) onAnimationDidEnd?.();
+		}),
+		create: vi.fn(createLayoutAnimationConfig),
+		easeInEaseOut: vi.fn((onAnimationDidEnd) => LayoutAnimation.configureNext(layoutAnimationPresets.easeInEaseOut, onAnimationDidEnd)),
+		linear: vi.fn((onAnimationDidEnd) => LayoutAnimation.configureNext(layoutAnimationPresets.linear, onAnimationDidEnd)),
+		setEnabled: vi.fn((value) => {
+			layoutAnimationEnabled = value;
+		}),
+		spring: vi.fn((onAnimationDidEnd) => LayoutAnimation.configureNext(layoutAnimationPresets.spring, onAnimationDidEnd))
+	};
+	const NativeDialogManagerAndroid = {
+		getConstants: vi.fn(() => ({
+			buttonClicked: "buttonClicked",
+			buttonNegative: "buttonNegative",
+			buttonNeutral: "buttonNeutral",
+			buttonPositive: "buttonPositive",
+			dismissed: "dismissed"
+		})),
+		showAlert: vi.fn((_config, _onError, onAction) => onAction("buttonClicked", "buttonPositive"))
+	};
+	const networkingEventEmitter = createEventEmitter();
+	const Networking = {
+		abortRequest: vi.fn(),
+		addListener: networkingEventEmitter.addListener,
+		clearCookies: vi.fn((callback) => callback(true)),
+		sendRequest: vi.fn((_method, _trackingName, _url, _headers, _data, _responseType, _incrementalUpdates, _timeout, callback) => callback(1))
+	};
+	const permissionsResults = {
+		DENIED: "denied",
+		GRANTED: "granted",
+		NEVER_ASK_AGAIN: "never_ask_again"
+	};
+	const PermissionsAndroid = {
+		PERMISSIONS: { CAMERA: "android.permission.CAMERA" },
+		RESULTS: permissionsResults,
+		check: vi.fn(async () => true),
+		request: vi.fn(async () => permissionsResults.GRANTED),
+		requestMultiple: vi.fn(async (requestedPermissions) => Object.fromEntries(requestedPermissions.map((permission) => [permission, permissionsResults.GRANTED]))),
+		shouldShowRequestPermissionRationale: vi.fn(async () => false)
+	};
+	const ToastAndroid = {
+		BOTTOM: 80,
+		CENTER: 17,
+		LONG: 1,
+		SHORT: 0,
+		TOP: 49,
+		show: vi.fn(),
+		showWithGravity: vi.fn(),
+		showWithGravityAndOffset: vi.fn()
+	};
+	const DevMenu = { show: vi.fn() };
+	const LogBox = {
+		ignoreAllLogs: vi.fn(),
+		ignoreLogs: vi.fn(),
+		install: vi.fn(),
+		uninstall: vi.fn()
+	};
+	class NativeEventEmitter {
+		nativeModule;
+		constructor(nativeModule) {
+			if (platformModule.default?.OS === "ios" && nativeModule == null) throw new Error("NativeEventEmitter requires a non-null argument.");
+			if (nativeModule && typeof nativeModule.addListener === "function" && typeof nativeModule.removeListeners === "function") this.nativeModule = nativeModule;
+		}
+		addListener(eventType, listener) {
+			this.nativeModule?.addListener?.(eventType);
+			let subscription = DeviceEventEmitter.addListener(eventType, listener);
+			return { remove: () => {
+				if (subscription != null) {
+					this.nativeModule?.removeListeners?.(1);
+					subscription.remove();
+					subscription = null;
+				}
+			} };
+		}
+		emit(eventType, ...args) {
+			DeviceEventEmitter.emit(eventType, ...args);
+		}
+		removeAllListeners(eventType) {
+			if (eventType == null) throw new Error("NativeEventEmitter.removeAllListeners requires a non-null argument.");
+			this.nativeModule?.removeListeners?.(DeviceEventEmitter.listenerCount(eventType));
+			DeviceEventEmitter.removeAllListeners(eventType);
+		}
+		listenerCount(eventType) {
+			return DeviceEventEmitter.listenerCount(eventType);
+		}
+	}
+	const PanResponder = { create: vi.fn((callbacks = {}) => {
+		const gestureState = {
+			_accountsForMovesUpTo: 0,
+			dx: 0,
+			dy: 0,
+			moveX: 0,
+			moveY: 0,
+			numberActiveTouches: 0,
+			stateID: 0,
+			vx: 0,
+			vy: 0,
+			x0: 0,
+			y0: 0
+		};
+		return {
+			getInteractionHandle: vi.fn(() => null),
+			panHandlers: {
+				onMoveShouldSetResponder: (...args) => callbacks.onMoveShouldSetPanResponder?.(...args, gestureState) ?? false,
+				onMoveShouldSetResponderCapture: (...args) => callbacks.onMoveShouldSetPanResponderCapture?.(...args, gestureState) ?? false,
+				onResponderEnd: (...args) => callbacks.onPanResponderEnd?.(...args, gestureState),
+				onResponderGrant: (...args) => callbacks.onPanResponderGrant?.(...args, gestureState) ?? false,
+				onResponderMove: (...args) => callbacks.onPanResponderMove?.(...args, gestureState),
+				onResponderReject: (...args) => callbacks.onPanResponderReject?.(...args, gestureState),
+				onResponderRelease: (...args) => callbacks.onPanResponderRelease?.(...args, gestureState),
+				onResponderStart: (...args) => callbacks.onPanResponderStart?.(...args, gestureState),
+				onResponderTerminate: (...args) => callbacks.onPanResponderTerminate?.(...args, gestureState),
+				onResponderTerminationRequest: (...args) => callbacks.onPanResponderTerminationRequest?.(...args, gestureState) ?? true,
+				onStartShouldSetResponder: (...args) => callbacks.onStartShouldSetPanResponder?.(...args, gestureState) ?? false,
+				onStartShouldSetResponderCapture: (...args) => callbacks.onStartShouldSetPanResponderCapture?.(...args, gestureState) ?? false
+			}
+		};
+	}) };
+	const pushNotificationManager = runtimeGlobals.nativeModuleProxy?.PushNotificationManager;
+	const PushNotificationIOS = {
+		abandonPermissions: vi.fn(() => pushNotificationManager?.abandonPermissions?.()),
+		addEventListener: vi.fn(),
+		getApplicationIconBadgeNumber: vi.fn((callback) => pushNotificationManager?.getApplicationIconBadgeNumber?.(callback)),
+		presentLocalNotification: vi.fn((notification) => pushNotificationManager?.presentLocalNotification?.(notification)),
+		removeAllDeliveredNotifications: vi.fn(() => pushNotificationManager?.removeAllDeliveredNotifications?.()),
+		removeEventListener: vi.fn(),
+		requestPermissions: vi.fn(() => pushNotificationManager?.requestPermissions?.())
+	};
+	let systraceEnabled = false;
+	let systraceCookie = 0;
+	const Systrace = {
+		beginAsyncEvent: vi.fn(() => systraceCookie++),
+		beginEvent: vi.fn(),
+		counterEvent: vi.fn(),
+		endAsyncEvent: vi.fn(),
+		endEvent: vi.fn(),
+		isEnabled: vi.fn(() => systraceEnabled),
+		setEnabled: vi.fn((enabled) => {
+			systraceEnabled = enabled;
+		})
+	};
+	const UTFSequence = Object.freeze({
+		BOM: "",
+		BULLET: "•",
+		BULLET_SP: "\xA0•\xA0",
+		MDASH: "—",
+		MDASH_SP: "\xA0—\xA0",
+		MIDDOT: "·",
+		MIDDOT_KATAKANA: "・",
+		MIDDOT_SP: "\xA0·\xA0",
+		NBSP: "\xA0",
+		NDASH: "–",
+		NDASH_SP: "\xA0–\xA0",
+		NEWLINE: "\n",
+		PIZZA: "🍕",
+		TRIANGLE_LEFT: "◀",
+		TRIANGLE_RIGHT: "▶"
+	});
+	const DynamicColorIOS = vi.fn(() => {
+		throw new Error("DynamicColorIOS is not available on this platform.");
+	});
+	class SectionList extends React.PureComponent {
+		flashScrollIndicators = vi.fn();
+		getScrollResponder = vi.fn(() => this.scrollViewRef);
+		getScrollableNode = vi.fn(() => this.scrollViewRef);
+		recordInteraction = vi.fn();
+		scrollToLocation = vi.fn();
+		setNativeProps = vi.fn();
+		scrollViewRef = null;
+		setScrollViewRef = (ref) => {
+			this.scrollViewRef = ref;
+		};
+		render() {
+			const { renderItem, renderSectionHeader, sections, ...props } = this.props;
+			const ScrollViewComponent = scrollViewModule.default ?? scrollViewModule;
+			return React.createElement(ScrollViewComponent, {
+				...props,
+				ref: this.setScrollViewRef
+			}, (sections ?? []).map((section, sectionIndex) => React.createElement(React.Fragment, { key: String(section.key ?? section.title ?? sectionIndex) }, renderSectionHeader?.({ section }), (section.data ?? []).map((item, itemIndex) => React.createElement(React.Fragment, { key: getItemKey(item, itemIndex, section.keyExtractor) }, renderItem?.({
+				index: itemIndex,
+				item,
+				section,
+				separators: createListSeparators()
+			}))))));
+		}
+	}
+	Object.defineProperty(SectionList, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "SectionList",
+		writable: true
+	});
+	class VirtualizedSectionList extends SectionList {}
+	Object.defineProperty(VirtualizedSectionList, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "VirtualizedSectionList",
+		writable: true
+	});
+	const RootTagContext = React.createContext(0);
+	RootTagContext.displayName = "RootTagContext";
+	const TextAncestorContext = React.createContext(false);
+	TextAncestorContext.displayName = "TextAncestorContext";
+	const sharedNativeMethods = createMockNativeMethods();
+	const NativeText = createMockNativeComponent(React, "RCTText");
+	const SafeAreaView = createMockHostComponent(React, "SafeAreaView", "View", sharedNativeMethods);
+	const VirtualView = createMockHostComponent(React, "VirtualView", "VirtualView", sharedNativeMethods);
+	const VirtualViewMode = Object.freeze({
+		Hidden: 2,
+		Prerender: 1,
+		Visible: 0
+	});
+	class Pressable extends React.Component {
+		render() {
+			const props = {
+				...this.props,
+				accessible: this.props.accessible ?? true
+			};
+			return React.createElement("View", props, props.children);
+		}
+	}
+	Object.assign(Pressable.prototype, sharedNativeMethods);
+	Object.defineProperty(Pressable, "displayName", {
+		configurable: true,
+		enumerable: true,
+		value: "Pressable",
+		writable: true
+	});
+	class AnimatedNode {
+		listeners = /* @__PURE__ */ new Set();
+		value;
+		constructor(initialValue) {
+			this.value = initialValue;
+		}
+		__getValue() {
+			return this.value;
+		}
+		addListener(listener) {
+			const wrapped = (value) => listener({ value });
+			this.listeners.add(wrapped);
+			return { remove: () => this.listeners.delete(wrapped) };
+		}
+		removeAllListeners() {
+			this.listeners.clear();
+		}
+		emitValue(nextValue) {
+			this.value = nextValue;
+			this.listeners.forEach((listener) => listener(nextValue));
+		}
+	}
+	class AnimatedValue extends AnimatedNode {
+		setValue(nextValue) {
+			this.emitValue(nextValue);
+		}
+	}
+	class AnimatedValueXY extends AnimatedNode {
+		x;
+		y;
+		constructor(initialValue) {
+			super(initialValue);
+			this.x = new AnimatedValue(initialValue.x);
+			this.y = new AnimatedValue(initialValue.y);
+		}
+		setValue(nextValue) {
+			this.x.setValue(nextValue.x);
+			this.y.setValue(nextValue.y);
+			this.emitValue({
+				x: nextValue.x,
+				y: nextValue.y
+			});
+		}
+	}
+	class AnimatedInterpolation extends AnimatedNode {}
+	class AnimatedColor extends AnimatedNode {}
+	const createAnimatedNode = (initialValue) => new AnimatedNode(initialValue);
+	const toAnimatedValue = (value) => value instanceof AnimatedNode ? value.__getValue() : value;
+	const createAnimation = (startImpl) => ({
+		reset: vi.fn(),
+		start: (callback) => {
+			startImpl(callback);
+		},
+		stop: vi.fn()
+	});
+	const runValueAnimation = (value, nextValue, duration, callback) => {
+		setTimeout(() => {
+			value.setValue(nextValue);
+			callback?.({ finished: true });
+		}, duration ?? 0);
+	};
+	function resolveAnimatedStyle(style) {
+		if (style instanceof AnimatedNode) return style.__getValue();
+		if (Array.isArray(style)) return style.map((value) => resolveAnimatedStyle(value));
+		if (style && typeof style === "object") return Object.fromEntries(Object.entries(style).map(([key, value]) => [key, resolveAnimatedStyle(value)]));
+		return style;
+	}
+	class AnimatedView extends React.Component {
+		subscriptions = [];
+		componentDidMount() {
+			this.subscribe(this.props.style);
+		}
+		componentDidUpdate(previousProps) {
+			if (previousProps.style !== this.props.style) {
+				this.unsubscribe();
+				this.subscribe(this.props.style);
+			}
+		}
+		componentWillUnmount() {
+			this.unsubscribe();
+		}
+		forceAnimatedUpdate = () => {
+			this.setState((state) => ({
+				...state ?? {},
+				animatedTick: Date.now()
+			}));
+		};
+		subscribe(style) {
+			const queue = [style];
+			while (queue.length > 0) {
+				const current = queue.shift();
+				if (current instanceof AnimatedNode) {
+					this.subscriptions.push(current.addListener(this.forceAnimatedUpdate));
+					continue;
+				}
+				if (Array.isArray(current)) {
+					queue.push(...current);
+					continue;
+				}
+				if (current && typeof current === "object") queue.push(...Object.values(current));
+			}
+		}
+		unsubscribe() {
+			this.subscriptions.forEach((subscription) => subscription.remove());
+			this.subscriptions = [];
+		}
+		render() {
+			const resolvedStyle = resolveAnimatedStyle(this.props.style);
+			return React.createElement("View", {
+				...this.props,
+				style: resolvedStyle
+			}, this.props.children);
+		}
+	}
+	class AnimatedEvent {
+		__isNative;
+		handler;
+		constructor(_argMapping, config) {
+			this.__isNative = Boolean(config?.useNativeDriver);
+			this.handler = (...args) => {
+				config?.listener?.(...args);
+			};
+		}
+	}
+	const createAnimatedComputation = (value) => createAnimatedNode(value);
+	const createCombinedHandler = (baseHandler, nextHandler) => Object.assign((...args) => {
+		baseHandler?.(...args);
+		nextHandler?.(...args);
+	}, {
+		__rntlBaseHandler: baseHandler,
+		__rntlExtraHandler: nextHandler
+	});
+	const Animated = {
+		Color: AnimatedColor,
+		Event: AnimatedEvent,
+		Interpolation: AnimatedInterpolation,
+		Node: AnimatedNode,
+		Value: AnimatedValue,
+		ValueXY: AnimatedValueXY,
+		add: (left, right) => createAnimatedComputation(Number(toAnimatedValue(left)) + Number(toAnimatedValue(right))),
+		attachNativeEvent: vi.fn(() => ({ detach: vi.fn() })),
+		View: AnimatedView,
+		createAnimatedComponent: (component) => component,
+		decay: (value, config) => createAnimation((callback) => runValueAnimation(value, value.__getValue() + Number(config.velocity ?? 0), 0, callback)),
+		delay: (duration) => createAnimation((callback) => {
+			setTimeout(() => callback?.({ finished: true }), duration);
+		}),
+		diffClamp: (value, min, max) => createAnimatedComputation(Math.max(min, Math.min(max, Number(toAnimatedValue(value))))),
+		divide: (left, right) => createAnimatedComputation(Number(toAnimatedValue(left)) / Number(toAnimatedValue(right))),
+		event: (argMapping, config) => new AnimatedEvent(argMapping, config).handler,
+		forkEvent: (event, listener) => createCombinedHandler(event, listener),
+		loop: (animation, config) => createAnimation((callback) => {
+			const iterations = config?.iterations ?? -1;
+			let runCount = 0;
+			const run = () => {
+				animation.start(() => {
+					runCount += 1;
+					if (iterations > 0 && runCount >= iterations) {
+						callback?.({ finished: true });
+						return;
+					}
+					run();
+				});
+			};
+			run();
+		}),
+		modulo: (left, right) => createAnimatedComputation(Number(toAnimatedValue(left)) % Number(toAnimatedValue(right))),
+		multiply: (left, right) => createAnimatedComputation(Number(toAnimatedValue(left)) * Number(toAnimatedValue(right))),
+		parallel: (animations) => createAnimation((callback) => {
+			if (animations.length === 0) {
+				callback?.({ finished: true });
+				return;
+			}
+			let completed = 0;
+			animations.forEach((animation) => {
+				animation.start(() => {
+					completed += 1;
+					if (completed === animations.length) callback?.({ finished: true });
+				});
+			});
+		}),
+		sequence: (animations) => createAnimation((callback) => {
+			let index = 0;
+			const run = () => {
+				if (index >= animations.length) {
+					callback?.({ finished: true });
+					return;
+				}
+				animations[index].start(() => {
+					index += 1;
+					run();
+				});
+			};
+			run();
+		}),
+		spring: (value, config) => createAnimation((callback) => runValueAnimation(value, config.toValue, 0, callback)),
+		stagger: (time, animations) => createAnimation((callback) => {
+			if (animations.length === 0) {
+				callback?.({ finished: true });
+				return;
+			}
+			let completed = 0;
+			animations.forEach((animation, index) => {
+				setTimeout(() => {
+					animation.start(() => {
+						completed += 1;
+						if (completed === animations.length) callback?.({ finished: true });
+					});
+				}, index * time);
+			});
+		}),
+		subtract: (left, right) => createAnimatedComputation(Number(toAnimatedValue(left)) - Number(toAnimatedValue(right))),
+		timing: (value, config) => createAnimation((callback) => runValueAnimation(value, config.toValue, config.duration, callback)),
+		unforkEvent: (event, _listener) => event.__rntlBaseHandler ?? event
+	};
+	const useAnimatedValue = (initialValue) => {
+		const ref = React.useRef(null);
+		if (ref.current == null) ref.current = new Animated.Value(initialValue);
+		return ref.current;
+	};
+	const reactNativeVersion = platformModule.default?.constants?.reactNativeVersion ?? {
+		major: 0,
+		minor: 0,
+		patch: 0,
+		prerelease: null
+	};
+	class ReactNativeVersion {
+		static major = reactNativeVersion.major ?? 0;
+		static minor = reactNativeVersion.minor ?? 0;
+		static patch = reactNativeVersion.patch ?? 0;
+		static prerelease = reactNativeVersion.prerelease ?? null;
+		static getVersionString() {
+			const prereleaseSuffix = ReactNativeVersion.prerelease != null ? `-${ReactNativeVersion.prerelease}` : "";
+			return `${ReactNativeVersion.major}.${ReactNativeVersion.minor}.${ReactNativeVersion.patch}${prereleaseSuffix}`;
+		}
+	}
+	const usePressability = vi.fn((config) => {
+		if (config == null) return null;
+		return Object.fromEntries(Object.entries(config).filter(([key, value]) => key.startsWith("on") && typeof value === "function"));
+	});
+	const reactNativeExports = {
+		__esModule: true,
+		AccessibilityInfo: accessibilityInfoModule.default ?? accessibilityInfoModule,
+		ActivityIndicator: activityIndicatorModule.default ?? activityIndicatorModule,
+		ActionSheetIOS,
+		Alert,
+		Animated,
+		Appearance,
+		AppRegistry,
+		AppState: appStateModule.default ?? appStateModule,
+		BackHandler,
+		Button,
+		Clipboard: clipboardModule.default ?? clipboardModule,
+		codegenNativeCommands: codegenNativeCommandsModule.default ?? codegenNativeCommandsModule,
+		codegenNativeComponent: codegenNativeComponentModule.default ?? codegenNativeComponentModule,
+		DevMenu,
+		DevSettings,
+		DeviceEventEmitter,
+		DeviceInfo,
+		DynamicColorIOS,
+		Dimensions,
+		DrawerLayoutAndroid,
+		findNodeHandle: rendererProxyModule.findNodeHandle,
+		FlatList,
+		I18nManager,
+		Image: imageModule.default ?? imageModule,
+		ImageBackground,
+		InputAccessoryView,
+		InteractionManager,
+		Keyboard,
+		KeyboardAvoidingView,
+		LayoutAnimation,
+		Linking: linkingModule.default ?? linkingModule,
+		LogBox,
+		Modal: modalModule.default ?? modalModule,
+		NativeComponentRegistry: nativeComponentRegistryModule.default ?? nativeComponentRegistryModule,
+		NativeDialogManagerAndroid,
+		NativeEventEmitter,
+		NativeModules: nativeModulesModule.default ?? nativeModulesModule,
+		NativeAppEventEmitter,
+		Networking,
+		PanResponder,
+		Platform: platformModule.default ?? platformModule,
+		PlatformColor,
+		PixelRatio,
+		PermissionsAndroid,
+		Pressable,
+		processColor,
+		ProgressBarAndroid,
+		PushNotificationIOS,
+		RefreshControl: refreshControlModule.default ?? refreshControlModule,
+		ReactNativeVersion,
+		registerCallableModule,
+		requireNativeComponent: requireNativeComponentModule.default ?? requireNativeComponentModule,
+		RootTagContext,
+		SafeAreaView,
+		ScrollView: scrollViewModule.default ?? scrollViewModule,
+		SectionList,
+		Settings,
+		Share,
+		StatusBar,
+		StyleSheet: styleSheetModule.default ?? styleSheetModule,
+		Switch,
+		Systrace,
+		Text: textModule.default ?? textModule,
+		TextInput: textInputModule.default ?? textInputModule,
+		Touchable,
+		TouchableHighlight,
+		TouchableNativeFeedback,
+		TouchableOpacity,
+		TouchableWithoutFeedback,
+		TurboModuleRegistry,
+		UIManager: uiManagerModule.default ?? uiManagerModule,
+		UTFSequence,
+		unstable_batchedUpdates: rendererProxyModule.unstable_batchedUpdates,
+		unstable_NativeText: NativeText,
+		unstable_NativeView: viewNativeComponentModule.default ?? viewNativeComponentModule,
+		unstable_TextAncestorContext: TextAncestorContext,
+		unstable_VirtualView: VirtualView,
+		useAnimatedValue,
+		useColorScheme: useColorSchemeModule.default ?? useColorSchemeModule,
+		usePressability,
+		useWindowDimensions,
+		Vibration: vibrationModule.default ?? vibrationModule,
+		View: viewModule.default ?? viewModule,
+		VirtualViewMode,
+		VirtualizedList,
+		VirtualizedSectionList,
+		ToastAndroid,
+		Easing,
+		experimental_LayoutConformance: LayoutConformance
+	};
+	for (const exportedName of [
+		"ART",
+		"ListView",
+		"SwipeableListView",
+		"WebView",
+		"NetInfo",
+		"CameraRoll",
+		"ImageStore",
+		"ImageEditor",
+		"TimePickerAndroid",
+		"ToolbarAndroid",
+		"ViewPagerAndroid",
+		"CheckBox",
+		"SegmentedControlIOS",
+		"StatusBarIOS",
+		"PickerIOS",
+		"Picker",
+		"DatePickerAndroid",
+		"MaskedViewIOS",
+		"AsyncStorage",
+		"ImagePickerIOS",
+		"ProgressViewIOS",
+		"DatePickerIOS",
+		"Slider"
+	]) Object.defineProperty(reactNativeExports, exportedName, {
+		configurable: true,
+		get() {
+			throw new Error(`${exportedName} has been removed from React Native.`);
+		}
+	});
+	sharedReactNativeExports = reactNativeExports;
+	return sharedReactNativeExports;
+}
+vi.mock("react-native/Libraries/Components/AccessibilityInfo/AccessibilityInfo", () => getSharedReactNativeMockModules().accessibilityInfoModule);
+vi.mock("react-native/Libraries/Core/InitializeCore", () => getSharedReactNativeMockModules().initializeCoreModule);
+vi.mock("react-native/Libraries/Core/NativeExceptionsManager", () => getSharedReactNativeMockModules().nativeExceptionsManagerModule);
+vi.mock("react-native/Libraries/Components/Clipboard/Clipboard", () => getSharedReactNativeMockModules().clipboardModule);
+vi.mock("react-native/Libraries/Utilities/codegenNativeCommands", () => getSharedReactNativeMockModules().codegenNativeCommandsModule);
+vi.mock("react-native/Libraries/Utilities/codegenNativeComponent", () => getSharedReactNativeMockModules().codegenNativeComponentModule);
+vi.mock("react-native/Libraries/Components/RefreshControl/RefreshControl", () => getSharedReactNativeMockModules().refreshControlModule);
+vi.mock("react-native/Libraries/Components/ActivityIndicator/ActivityIndicator", () => getSharedReactNativeMockModules().activityIndicatorModule);
+vi.mock("react-native/Libraries/Image/Image", () => getSharedReactNativeMockModules().imageModule);
+vi.mock("react-native/Libraries/Text/Text", () => getSharedReactNativeMockModules().textModule);
+vi.mock("react-native/Libraries/Components/TextInput/TextInput", () => getSharedReactNativeMockModules().textInputModule);
+vi.mock("react-native/Libraries/Modal/Modal", () => getSharedReactNativeMockModules().modalModule);
+vi.mock("react-native/Libraries/Components/View/View", () => getSharedReactNativeMockModules().viewModule);
+vi.mock("react-native/Libraries/Components/ScrollView/ScrollView", () => getSharedReactNativeMockModules().scrollViewModule);
+vi.mock("react-native/Libraries/BatchedBridge/NativeModules", () => getSharedReactNativeMockModules().nativeModulesModule);
+vi.mock("react-native/Libraries/ReactNative/UIManager", () => getSharedReactNativeMockModules().uiManagerModule);
+vi.mock("react-native/Libraries/AppState/AppState", () => getSharedReactNativeMockModules().appStateModule);
+vi.mock("react-native/Libraries/Linking/Linking", () => getSharedReactNativeMockModules().linkingModule);
+vi.mock("react-native/Libraries/Vibration/Vibration", () => getSharedReactNativeMockModules().vibrationModule);
+vi.mock("react-native/Libraries/NativeComponent/NativeComponentRegistry", () => getSharedReactNativeMockModules().nativeComponentRegistryModule);
+vi.mock("react-native/Libraries/ReactNative/requireNativeComponent", () => getSharedReactNativeMockModules().requireNativeComponentModule);
+vi.mock("react-native/Libraries/Components/View/ViewNativeComponent", () => getSharedReactNativeMockModules().viewNativeComponentModule);
+vi.mock("react-native/Libraries/StyleSheet/StyleSheet", () => getSharedReactNativeMockModules().styleSheetModule);
+vi.mock("react-native/Libraries/Utilities/useColorScheme", () => getSharedReactNativeMockModules().useColorSchemeModule);
+vi.mock("react-native/Libraries/Utilities/Platform", () => getSharedReactNativeMockModules().platformModule);
+vi.mock("react-native/Libraries/ReactNative/RendererProxy", () => getSharedReactNativeMockModules().rendererProxyModule);
+function patchReactNativeResolution() {
+	if (runtimeGlobals.__rntlVitestRnResolverPatched__ === true) return;
+	const moduleWithPrivateResolver = Module;
+	const originalResolveFilename = moduleWithPrivateResolver._resolveFilename;
+	const originalLoad = moduleWithPrivateResolver._load;
+	const reactNativeIndexPath = path.join(reactNativeMirrorRoot, "react-native", "index.js");
+	const nativeComponentRegistryMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "NativeComponent", "NativeComponentRegistry.js");
+	const requireNativeComponentMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "ReactNative", "requireNativeComponent.js");
+	const initializeCoreMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Core", "InitializeCore.js");
+	const nativeExceptionsManagerMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Core", "NativeExceptionsManager.js");
+	const accessibilityInfoMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "AccessibilityInfo", "AccessibilityInfo.js");
+	const clipboardMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "Clipboard", "Clipboard.js");
+	const codegenNativeCommandsMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Utilities", "codegenNativeCommands.js");
+	const codegenNativeComponentMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Utilities", "codegenNativeComponent.js");
+	const refreshControlMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "RefreshControl", "RefreshControl.js");
+	const activityIndicatorMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "ActivityIndicator", "ActivityIndicator.js");
+	const imageMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Image", "Image.js");
+	const textMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Text", "Text.js");
+	const textInputMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "TextInput", "TextInput.js");
+	const modalMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Modal", "Modal.js");
+	const viewMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "View", "View.js");
+	const scrollViewMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "ScrollView", "ScrollView.js");
+	const nativeModulesMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "BatchedBridge", "NativeModules.js");
+	const uiManagerMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "ReactNative", "UIManager.js");
+	const appStateMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "AppState", "AppState.js");
+	const linkingMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Linking", "Linking.js");
+	const vibrationMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Vibration", "Vibration.js");
+	const viewNativeComponentMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "View", "ViewNativeComponent.js");
+	const useColorSchemeMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Utilities", "useColorScheme.js");
+	const platformMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Utilities", "Platform.js");
+	const styleSheetMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "StyleSheet", "StyleSheet.js");
+	const sharedMockModules = getSharedReactNativeMockModules();
+	const tryResolveMirroredPackageRequest = (request) => {
+		if (request === "jest-react-native") return path.join(reactNativeMirrorRoot, "jest-react-native");
+		if (request.startsWith("jest-react-native/")) return path.join(reactNativeMirrorRoot, "jest-react-native", request.slice(18));
+		if (request.startsWith("@react-native-community/")) return path.join(reactNativeMirrorRoot, ...request.split("/"));
+		return null;
+	};
+	const isMirroredPackageManifestRequest = (request) => request === "react-native/package.json" || request === "jest-react-native/package.json" || request.startsWith("@react-native/") && request.endsWith("/package.json") || request.startsWith("@react-native-community/") && request.endsWith("/package.json");
+	moduleWithPrivateResolver._resolveFilename = function patchedResolveFilename(request, parent, isMain, options) {
+		if (isMirroredPackageManifestRequest(request)) return originalResolveFilename.call(this, request, parent, isMain, options);
+		if (request === "react-native") return originalResolveFilename.call(this, reactNativeIndexPath, parent, isMain, options);
+		if (request.startsWith("react-native/")) return originalResolveFilename.call(this, path.join(reactNativeMirrorRoot, "react-native", request.slice(13)), parent, isMain, options);
+		if (request.startsWith("@react-native/")) return originalResolveFilename.call(this, path.join(reactNativeMirrorRoot, request), parent, isMain, options);
+		const mirroredPackageRequest = tryResolveMirroredPackageRequest(request);
+		if (mirroredPackageRequest != null) return originalResolveFilename.call(this, mirroredPackageRequest, parent, isMain, options);
+		return originalResolveFilename.call(this, request, parent, isMain, options);
+	};
+	moduleWithPrivateResolver._load = function patchedLoad(request, parent, isMain) {
+		const resolved = moduleWithPrivateResolver._resolveFilename(request, parent, isMain);
+		if (resolved === reactNativeIndexPath) return getSharedReactNativeExports();
+		if (resolved === nativeComponentRegistryMockPath) return sharedMockModules.nativeComponentRegistryModule;
+		if (resolved === requireNativeComponentMockPath) return sharedMockModules.requireNativeComponentModule;
+		if (resolved === initializeCoreMockPath) return sharedMockModules.initializeCoreModule;
+		if (resolved === nativeExceptionsManagerMockPath) return sharedMockModules.nativeExceptionsManagerModule;
+		if (resolved === accessibilityInfoMockPath) return sharedMockModules.accessibilityInfoModule;
+		if (resolved === clipboardMockPath) return sharedMockModules.clipboardModule;
+		if (resolved === codegenNativeCommandsMockPath) return sharedMockModules.codegenNativeCommandsModule;
+		if (resolved === codegenNativeComponentMockPath) return sharedMockModules.codegenNativeComponentModule;
+		if (resolved === refreshControlMockPath) return sharedMockModules.refreshControlModule;
+		if (resolved === activityIndicatorMockPath) return sharedMockModules.activityIndicatorModule;
+		if (resolved === imageMockPath) return sharedMockModules.imageModule;
+		if (resolved === textMockPath) return sharedMockModules.textModule;
+		if (resolved === textInputMockPath) return sharedMockModules.textInputModule;
+		if (resolved === modalMockPath) return sharedMockModules.modalModule;
+		if (resolved === viewMockPath) return sharedMockModules.viewModule;
+		if (resolved === scrollViewMockPath) return sharedMockModules.scrollViewModule;
+		if (resolved === nativeModulesMockPath) return sharedMockModules.nativeModulesModule;
+		if (resolved === uiManagerMockPath) return sharedMockModules.uiManagerModule;
+		if (resolved === appStateMockPath) return sharedMockModules.appStateModule;
+		if (resolved === linkingMockPath) return sharedMockModules.linkingModule;
+		if (resolved === vibrationMockPath) return sharedMockModules.vibrationModule;
+		if (resolved === viewNativeComponentMockPath) return sharedMockModules.viewNativeComponentModule;
+		if (resolved === useColorSchemeMockPath) return sharedMockModules.useColorSchemeModule;
+		if (resolved === platformMockPath) return sharedMockModules.platformModule;
+		if (resolved === styleSheetMockPath) return sharedMockModules.styleSheetModule;
+		if (REACT_NATIVE_ASSET_MODULE_ID_PATTERN.test(resolved)) return { testUri: path.relative(runtimeDirectory, resolved.replace(/[?#].*$/, "")).replace(/\\/g, "/") };
+		return originalLoad.call(this, request, parent, isMain);
+	};
+	runtimeGlobals.__rntlVitestRnResolverPatched__ = true;
+}
+vi.mock("react-native", () => getSharedReactNativeExports());
+installReactNativeGlobals(runtimeGlobals);
+installNativeModuleProxy(runtimeGlobals);
+patchReactNativeResolution();
+
+//#endregion
+export { createMockHostComponent, createMockNativeComponent };