@tamagui/static 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/extractor/regenerateConfig.cjs

@@ -0,0 +1,161 @@
+
+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 regenerateConfig_exports = {};
+__export(regenerateConfig_exports, {
+	generateTamaguiThemes: () => generateTamaguiThemes,
+	regenerateConfig: () => regenerateConfig,
+	regenerateConfigSync: () => regenerateConfigSync
+});
+module.exports = __toCommonJS(regenerateConfig_exports);
+var import_node_path = require("node:path");
+var import_node_module = require("node:module");
+var import_generate_themes = require("@tamagui/generate-themes");
+var import_helpers = require("@tamagui/helpers");
+var import_style_grammar = require("@tamagui/style-grammar");
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_requireTamaguiCore = require("../helpers/requireTamaguiCore.cjs");
+var import_bundleConfig = require("./bundleConfig.cjs");
+async function regenerateConfig(tamaguiOptions, configIn, rebuild = false) {
+	try {
+		const config = configIn ?? await (0, import_bundleConfig.getBundledConfig)(tamaguiOptions, rebuild);
+		if (!config) return;
+		const out = transformConfig(config, tamaguiOptions.platform || "web");
+		const confFile = getConfigFile(tamaguiOptions);
+		await import_fs_extra.default.ensureDir((0, import_node_path.dirname)(confFile));
+		await import_fs_extra.default.writeJSON(confFile, out, { spaces: 2 });
+	} catch (err) {
+		if (process.env.DEBUG?.includes("tamagui") || process.env.IS_TAMAGUI_DEV) {
+			console.warn("regenerateConfig error", err);
+		}
+	}
+}
+function regenerateConfigSync(tamaguiOptions, config) {
+	try {
+		const confFile = getConfigFile(tamaguiOptions);
+		import_fs_extra.default.ensureDirSync((0, import_node_path.dirname)(confFile));
+		import_fs_extra.default.writeJSONSync(confFile, transformConfig(config, tamaguiOptions.platform || "web"), { spaces: 2 });
+	} catch (err) {
+		if (process.env.DEBUG?.includes("tamagui") || process.env.IS_TAMAGUI_DEV) {
+			console.warn("regenerateConfig error", err);
+		}
+	}
+}
+async function generateTamaguiThemes(tamaguiOptions, force = false) {
+	if (!tamaguiOptions.themeBuilder) {
+		return;
+	}
+	const { input, output } = tamaguiOptions.themeBuilder;
+	const root = tamaguiOptions.root || process.cwd();
+	const tamaguiDir = (0, import_node_path.join)(root, ".tamagui");
+	const projectRequire = (0, import_node_module.createRequire)((0, import_node_path.join)(root, "package.json"));
+	const inPath = resolveRelativePath(input, root, projectRequire);
+	const outPath = resolveRelativePath(output, root, projectRequire);
+	const generatedOutput = await (0, import_generate_themes.generateThemes)(inPath);
+	const hasChanged = force || await (async () => {
+		try {
+			if (!generatedOutput) return false;
+			const next = generatedOutput.generated;
+			const current = await import_fs_extra.default.readFile(outPath, "utf-8");
+			return next !== current;
+		} catch (err) {}
+		return true;
+	})();
+	if (hasChanged) {
+		await (0, import_generate_themes.writeGeneratedThemes)(tamaguiDir, outPath, generatedOutput);
+	}
+	return hasChanged;
+}
+const getConfigFile = (options) => (0, import_node_path.join)(options.root || process.cwd(), ".tamagui", "tamagui.config.json");
+const resolveRelativePath = (inputPath, root, projectRequire) => inputPath.startsWith(".") ? (0, import_node_path.join)(root, inputPath) : projectRequire.resolve(inputPath);
+function cloneDeepSafe(x, excludeKeys = {}) {
+	if (!x) return x;
+	if (Array.isArray(x)) return x.map((_) => cloneDeepSafe(_));
+	if (typeof x === "function") return `Function`;
+	if (typeof x !== "object") return x;
+	if ("$$typeof" in x) return "Component";
+	return Object.fromEntries(Object.entries(x).flatMap(([k, v]) => excludeKeys[k] ? [] : [[k, cloneDeepSafe(v)]]));
+}
+function buildPropCategories() {
+	const out = {};
+	const byPrefix = {};
+	for (const entry of import_style_grammar.grammarEntries) {
+		if (entry.tokenCategory) out[entry.prop] = entry.tokenCategory;
+		if (entry.prefix) (byPrefix[entry.prefix] ||= /* @__PURE__ */ new Set()).add(entry.tokenCategory);
+	}
+	for (const [prefix, categories] of Object.entries(byPrefix)) {
+		if (categories.size !== 1) continue;
+		const [only] = categories;
+		if (only) out[prefix] = only;
+	}
+	return out;
+}
+function transformConfig(config, platform) {
+	if (!config) {
+		return null;
+	}
+	const { getVariableValue } = (0, import_requireTamaguiCore.requireTamaguiCore)(platform);
+	const next = cloneDeepSafe(config, { validStyles: true });
+	const { components, nameToPaths, tamaguiConfig } = next;
+	const { themes, tokens } = tamaguiConfig;
+	for (const key in themes) {
+		const theme = themes[key];
+		for (const tkey in theme) {
+			theme[tkey] = getVariableValue(theme[tkey]);
+		}
+	}
+	for (const key in tokens) {
+		const token = { ...tokens[key] };
+		for (const tkey in token) {
+			token[tkey] = getVariableValue(token[tkey]);
+		}
+	}
+	for (const component of components) {
+		for (const _ in component.nameToInfo) {
+			const compDefinition = { ...component.nameToInfo[_] };
+			component.nameToInfo[_] = compDefinition;
+			const { parentStaticConfig, ...rest } = compDefinition.staticConfig;
+			compDefinition.staticConfig = rest;
+		}
+	}
+	next.nameToPaths = {};
+	for (const key in nameToPaths) {
+		next.nameToPaths[key] = [...nameToPaths[key]];
+	}
+	const { fontsParsed, getCSS, tokensParsed, themeConfig, shorthands: _shorthands, userShorthands, ...cleanedConfig } = next.tamaguiConfig;
+	return {
+		components,
+		nameToPaths,
+		tamaguiConfigMetadata: { themeFields: "values-only" },
+		tamaguiConfig: {
+			...cleanedConfig,
+			shorthands: userShorthands,
+			propCategories: buildPropCategories(),
+			styleProps: Object.keys(import_helpers.stylePropsAll)
+		}
+	};
+}

package/dist/cjs/extractor/watchTamaguiConfig.cjs

@@ -0,0 +1,64 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var watchTamaguiConfig_exports = {};
+__export(watchTamaguiConfig_exports, { watchTamaguiConfig: () => watchTamaguiConfig });
+module.exports = __toCommonJS(watchTamaguiConfig_exports);
+var import_node_module = require("node:module");
+var import_loadTamagui = require("./loadTamagui.cjs");
+var import_regenerateConfig = require("./regenerateConfig.cjs");
+const import_meta = {};
+const nodeRequire = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+let isWatching = false;
+async function watchTamaguiConfig(tamaguiOptions) {
+	if (process.env.NODE_ENV === "production" || tamaguiOptions.disable) {
+		return { dispose() {} };
+	}
+	if (isWatching) {
+		return;
+	}
+	isWatching = true;
+	const options = await (0, import_loadTamagui.getOptions)({ tamaguiOptions });
+	if (!options.tamaguiOptions.config) {
+		isWatching = false;
+		throw new Error(`No config`);
+	}
+	const disposeConfigWatcher = await (0, import_loadTamagui.esbuildWatchFiles)(options.tamaguiOptions.config, async () => {
+		await (0, import_loadTamagui.generateThemesAndLog)(options.tamaguiOptions);
+		await (0, import_regenerateConfig.regenerateConfig)(options.tamaguiOptions, null, true);
+	});
+	const themeBuilderInput = options.tamaguiOptions.themeBuilder?.input;
+	let disposeThemesWatcher;
+	if (themeBuilderInput) {
+		let inputPath = themeBuilderInput;
+		try {
+			inputPath = nodeRequire.resolve(themeBuilderInput);
+		} catch {}
+		disposeThemesWatcher = await (0, import_loadTamagui.esbuildWatchFiles)(inputPath, async () => {
+			await (0, import_loadTamagui.generateThemesAndLog)(options.tamaguiOptions);
+		});
+	}
+	return { dispose() {
+		isWatching = false;
+		disposeConfigWatcher();
+		disposeThemesWatcher?.();
+	} };
+}

package/dist/cjs/getPragmaOptions.cjs

@@ -0,0 +1,67 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getPragmaOptions_exports = {};
+__export(getPragmaOptions_exports, { getPragmaOptions: () => getPragmaOptions });
+module.exports = __toCommonJS(getPragmaOptions_exports);
+function getPragmaOptions({ source, path }) {
+	let shouldPrintDebug = false;
+	let shouldDisable = false;
+	const firstLines = source.slice(0, 800);
+	let pragma = "";
+	for (const line of firstLines.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed && !trimmed.startsWith("//") && !trimmed.startsWith("/*")) {
+			break;
+		}
+		pragma = trimmed.match(/(\/\/|\/\*)\s?!?\s?(tamagui-ignore|debug|debug-verbose)(\n|\s|$).*/)?.[2].trim() || "";
+		if (pragma) {
+			pragma = pragma.replace("!", "").trim();
+			break;
+		}
+	}
+	switch (pragma) {
+		case "tamagui-ignore":
+			shouldDisable = true;
+			break;
+		case "debug":
+			shouldPrintDebug = true;
+			break;
+		case "debug-verbose":
+			shouldPrintDebug = "verbose";
+			break;
+	}
+	if (process.env.TAMAGUI_DEBUG_FILE) {
+		if (path.includes(process.env.TAMAGUI_DEBUG_FILE)) {
+			shouldPrintDebug = "verbose";
+		}
+	}
+	if (process.env.DEBUG?.includes("tamagui")) {
+		shouldPrintDebug ||= true;
+	}
+	if (process.env.DEBUG?.includes("tamagui-verbose")) {
+		shouldPrintDebug = "verbose";
+	}
+	return {
+		shouldPrintDebug,
+		shouldDisable
+	};
+}

package/dist/cjs/helpers/memoize.cjs

@@ -0,0 +1,42 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var memoize_exports = {};
+__export(memoize_exports, { memoize: () => memoize });
+module.exports = __toCommonJS(memoize_exports);
+function memoize(func, resolver) {
+	if (typeof func !== "function" || resolver != null && typeof resolver !== "function") {
+		throw new TypeError("Expected a function");
+	}
+	const memoized = function(...args) {
+		const key = resolver ? resolver.apply(this, args) : args[0];
+		const cache = memoized.cache;
+		if (cache.has(key)) {
+			return cache.get(key);
+		}
+		const result = func.apply(this, args);
+		memoized.cache = cache.set(key, result) || cache;
+		return result;
+	};
+	memoized.cache = new (memoize.Cache || Map)();
+	return memoized;
+}
+memoize.Cache = Map;

package/dist/cjs/helpers/requireTamaguiCore.cjs

@@ -0,0 +1,40 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var requireTamaguiCore_exports = {};
+__export(requireTamaguiCore_exports, { requireTamaguiCore: () => requireTamaguiCore });
+module.exports = __toCommonJS(requireTamaguiCore_exports);
+var import_node_module = require("node:module");
+const import_meta = {};
+const nodeRequire = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+function requireTamaguiCore(platform, ogRequire = nodeRequire) {
+	if (!platform) {
+		throw new Error(`No platform given to requireTamaguiCore`);
+	}
+	const og1 = process.env.TAMAGUI_IS_SERVER;
+	const og2 = process.env.TAMAGUI_KEEP_THEMES;
+	process.env.TAMAGUI_IS_SERVER ||= "1";
+	process.env.TAMAGUI_KEEP_THEMES ||= "1";
+	const exported = ogRequire(platform === "native" ? "@tamagui/core/native" : "@tamagui/core");
+	process.env.TAMAGUI_IS_SERVER = og1;
+	process.env.TAMAGUI_KEEP_THEMES = og2;
+	return exported;
+}

package/dist/cjs/index.cjs

@@ -0,0 +1,34 @@
+
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 index_exports = {};
+__export(index_exports, { default: () => index_default });
+module.exports = __toCommonJS(index_exports);
+var Static1 = __toESM(require("./exports.cjs"), 1);
+__reExport(index_exports, require("./exports.cjs"), module.exports);
+var index_default = Static1;

package/dist/cjs/registerRequire.cjs

@@ -0,0 +1,220 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registerRequire_exports = {};
+__export(registerRequire_exports, {
+	getNameToPaths: () => getNameToPaths,
+	registerRequire: () => registerRequire,
+	setRequireResult: () => setRequireResult
+});
+module.exports = __toCommonJS(registerRequire_exports);
+var import_node_path = require("node:path");
+var import_esbuild = require("esbuild");
+var import_node = require("esbuild-register/dist/node");
+var import_node_module = require("node:module");
+var import_bundle = require("./extractor/bundle.cjs");
+var import_requireTamaguiCore = require("./helpers/requireTamaguiCore.cjs");
+var import_staticEvaluationIgnoredModules = require("./staticEvaluationIgnoredModules.cjs");
+const import_meta = {};
+const nameToPaths = {};
+const nodeRequire = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+const getNameToPaths = () => nameToPaths;
+const Module = nodeRequire("node:module");
+let isRegistered = false;
+let og;
+var StaticEvaluationError = class extends Error {
+	constructor(moduleName, importer, failedModule, reason, options) {
+		super(`[tamagui] Failed to evaluate module "${failedModule}" imported from "${importer}" while loading the Tamagui config and configured components.
+Reason: ${reason}
+Fix the module so it can run in Node during the build. If it is runtime-only and none of its exports create your Tamagui config or components, add "${moduleName}" to dangerouslyIgnoreStaticEvaluationModules in tamagui.build.ts.`, options);
+		this.moduleName = moduleName;
+		this.importer = importer;
+		this.failedModule = failedModule;
+		this.reason = reason;
+	}
+	moduleName;
+	importer;
+	failedModule;
+	reason;
+	code = "TAMAGUI_STATIC_EVALUATION_ERROR";
+};
+const compiled = {};
+function setRequireResult(name, result) {
+	compiled[name] = result;
+}
+function getStaticExtractionStub(path) {
+	switch (path) {
+		case "expo-constants": return {
+			__esModule: true,
+			default: { executionEnvironment: null },
+			ExecutionEnvironment: {
+				Bare: "bare",
+				Standalone: "standalone",
+				StoreClient: "storeClient"
+			}
+		};
+		case "expo-updates": return {
+			__esModule: true,
+			default: {
+				isEnabled: false,
+				isUsingEmbeddedAssets: true
+			},
+			checkForUpdateAsync: async () => ({ isAvailable: false }),
+			fetchUpdateAsync: async () => ({ isNew: false }),
+			reloadAsync: async () => {}
+		};
+		case "react-native-reanimated": {
+			const identity = (value) => value;
+			const sharedValue = (value) => ({
+				value,
+				get: () => value,
+				set: (next) => {
+					value = typeof next === "function" ? next(value) : next;
+				}
+			});
+			const Animated = {
+				createAnimatedComponent: identity,
+				View: () => null,
+				Text: () => null
+			};
+			return {
+				__esModule: true,
+				default: Animated,
+				cancelAnimation: () => {},
+				runOnJS: identity,
+				runOnUI: identity,
+				useAnimatedReaction: () => {},
+				useAnimatedStyle: (callback) => callback(),
+				useDerivedValue: (callback) => sharedValue(callback()),
+				useSharedValue: sharedValue,
+				withDelay: (_delay, animation) => animation,
+				withSpring: identity,
+				withTiming: identity
+			};
+		}
+		default: return null;
+	}
+}
+function registerRequire(platform, { ignoredModules = [] } = { ignoredModules: [] }) {
+	if (isRegistered) {
+		return {
+			tamaguiRequire: nodeRequire,
+			unregister: () => {}
+		};
+	}
+	const originalResolveFilename = Module._resolveFilename;
+	const { unregister } = (0, import_node.register)({
+		hookIgnoreNodeModules: false,
+		hookMatcher: (filename) => {
+			if (filename.includes("@tamagui") || /\/tamagui\/code\/(core|ui|packages)\//.test(filename)) {
+				return false;
+			}
+			return true;
+		}
+	});
+	const tsconfigPatchedResolve = Module._resolveFilename;
+	Module._resolveFilename = function(request, ...args) {
+		if (request.startsWith("@tamagui/")) {
+			return originalResolveFilename.call(this, request, ...args);
+		}
+		return tsconfigPatchedResolve.call(this, request, ...args);
+	};
+	if (!og) {
+		og = Module.prototype.require;
+	}
+	isRegistered = true;
+	Module.prototype.require = tamaguiRequire;
+	function tamaguiRequire(path) {
+		const staticExtractionStub = getStaticExtractionStub(path);
+		if (staticExtractionStub) {
+			return staticExtractionStub;
+		}
+		if (path === "tamagui" && platform === "native") {
+			return og.apply(this, ["tamagui/native"]);
+		}
+		if (path === "@tamagui/core") {
+			return (0, import_requireTamaguiCore.requireTamaguiCore)(platform, (path2) => {
+				return og.apply(this, [path2]);
+			});
+		}
+		const staticEvaluationReplacement = (0, import_staticEvaluationIgnoredModules.getStaticEvaluationModuleReplacement)(path);
+		if (staticEvaluationReplacement) {
+			if (!(path in compiled)) {
+				const replacementPath = nodeRequire.resolve(staticEvaluationReplacement);
+				const output = (0, import_esbuild.buildSync)({
+					entryPoints: [replacementPath],
+					bundle: true,
+					format: "cjs",
+					platform: "node",
+					write: false
+				}).outputFiles[0].text;
+				const replacementModule = new Module(replacementPath, this);
+				replacementModule.filename = replacementPath;
+				replacementModule.paths = Module._nodeModulePaths((0, import_node_path.dirname)(replacementPath));
+				replacementModule._compile(output, replacementPath);
+				compiled[path] = replacementModule.exports;
+			}
+			return compiled[path];
+		}
+		if (staticEvaluationReplacement === null || (0, import_staticEvaluationIgnoredModules.isIgnoredStaticEvaluationModule)(path, ignoredModules)) {
+			return {};
+		}
+		if (import_bundle.esbuildIgnoreFilesRegex.test(path)) {
+			return {};
+		}
+		if (path in compiled) {
+			return compiled[path];
+		}
+		if (path === "react-native-svg") {
+			return og.apply(this, ["@tamagui/react-native-svg"]);
+		}
+		if (path === "react-native/package.json") {
+			return og.apply(this, ["react-native-web/package.json"]);
+		}
+		if (path === "@tamagui/react-native-web-lite" || path === "react-native" || path.startsWith("react-native/") || path === "react-native-web" || path.startsWith("react-native-web/")) {
+			try {
+				return og.apply("react-native");
+			} catch {
+				return og.apply(this, ["@tamagui/react-native-web-lite"]);
+			}
+		}
+		try {
+			const out = og.apply(this, arguments);
+			return out;
+		} catch (err) {
+			if (err?.code === "TAMAGUI_STATIC_EVALUATION_ERROR") {
+				throw err;
+			}
+			const importer = this?.filename || this?.id || "<unknown module>";
+			const reason = err instanceof Error ? err.message : String(err);
+			const failedModule = reason.match(/Cannot find native module ['"]([^'"]+)['"]/)?.[1] || path;
+			throw new StaticEvaluationError(path, importer, failedModule, reason, { cause: err });
+		}
+	}
+	return {
+		tamaguiRequire,
+		unregister: () => {
+			unregister();
+			isRegistered = false;
+			Module.prototype.require = og;
+		}
+	};
+}