@tamagui/static 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/extractor/concatClassName.cjs

@@ -0,0 +1,117 @@
+
+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 concatClassName_exports = {};
+__export(concatClassName_exports, { concatClassName: () => concatClassName });
+module.exports = __toCommonJS(concatClassName_exports);
+function concatClassName(_cn) {
+	const args = arguments;
+	const usedPrefixes = /* @__PURE__ */ new Set();
+	let final = "";
+	const len = args.length;
+	let propObjects = null;
+	for (let x = len; x >= 0; x--) {
+		const cns = args[x];
+		if (!cns) continue;
+		if (!Array.isArray(cns) && typeof cns !== "string") {
+			propObjects = propObjects || [];
+			propObjects.push(cns);
+			continue;
+		}
+		const names = Array.isArray(cns) ? cns : cns.split(" ");
+		const numNames = names.length;
+		for (let i = numNames - 1; i >= 0; i--) {
+			const name = names[i];
+			if (!name || name === " ") continue;
+			if (name.startsWith("font_")) {
+				if (usedPrefixes.has("fontFamily")) {
+					continue;
+				}
+				usedPrefixes.add("fontFamily");
+				final = name + " " + final;
+				continue;
+			}
+			if (name[0] !== "_") {
+				final = name + " " + final;
+				continue;
+			}
+			const splitIndex = name.indexOf("-");
+			if (splitIndex < 1) {
+				final = name + " " + final;
+				continue;
+			}
+			const styleKey = name.slice(1, name.indexOf("-"));
+			const { mediaKey, pseudoKey } = getClassNameScope(name, splitIndex);
+			const uid = `${styleKey}${mediaKey ? `@${mediaKey}` : ""}${pseudoKey ? `:${pseudoKey}` : ""}`;
+			if (usedPrefixes.has(uid)) {
+				continue;
+			}
+			usedPrefixes.add(uid);
+			const propName = styleKey;
+			if (propName && propObjects) {
+				if (propObjects.some((po) => {
+					return po && propName in po && po[propName] !== null;
+				})) {
+					continue;
+				}
+			}
+			final = name + " " + final;
+		}
+	}
+	return final.trim();
+}
+function getClassNameScope(name, splitIndex) {
+	let mediaKey = "";
+	let pseudoKey = "";
+	let valueStart = splitIndex + 1;
+	if (name[valueStart] === "_") {
+		const mediaEnd = name.indexOf("_", valueStart + 1);
+		if (mediaEnd > valueStart + 1) {
+			mediaKey = name.slice(valueStart + 1, mediaEnd);
+			valueStart = mediaEnd + 1;
+		}
+	}
+	if (name[valueStart] === "0") {
+		const pseudoStart = valueStart + 1;
+		for (const nextPseudoKey of pseudoKeys) {
+			if (name.startsWith(`${nextPseudoKey}-`, pseudoStart)) {
+				pseudoKey = nextPseudoKey;
+				break;
+			}
+		}
+	}
+	return {
+		mediaKey,
+		pseudoKey
+	};
+}
+const pseudoKeys = [
+	"focus-visible",
+	"focus-within",
+	"focusVisible",
+	"focusWithin",
+	"disabled",
+	"active",
+	"hover",
+	"focus",
+	"enter",
+	"exit"
+];

package/dist/cjs/extractor/detectModuleFormat.cjs

@@ -0,0 +1,54 @@
+
+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 detectModuleFormat_exports = {};
+__export(detectModuleFormat_exports, {
+	clearFormatCache: () => clearFormatCache,
+	detectModuleFormat: () => detectModuleFormat
+});
+module.exports = __toCommonJS(detectModuleFormat_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+const formatCache = /* @__PURE__ */ new Map();
+function detectModuleFormat(filePath) {
+	const ext = (0, import_node_path.extname)(filePath);
+	if (ext === ".mjs") return "esm";
+	if (ext === ".cjs") return "cjs";
+	let dir = (0, import_node_path.dirname)(filePath);
+	while (true) {
+		if (formatCache.has(dir)) {
+			return formatCache.get(dir);
+		}
+		try {
+			const pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(dir, "package.json"), "utf-8"));
+			const format = pkg.type === "module" ? "esm" : "cjs";
+			formatCache.set(dir, format);
+			return format;
+		} catch {}
+		const parent = (0, import_node_path.dirname)(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return "cjs";
+}
+function clearFormatCache() {
+	formatCache.clear();
+}

package/dist/cjs/extractor/esbuildAliasPlugin.cjs

@@ -0,0 +1,47 @@
+
+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 esbuildAliasPlugin_exports = {};
+__export(esbuildAliasPlugin_exports, { esbuildAliasPlugin: () => esbuildAliasPlugin });
+module.exports = __toCommonJS(esbuildAliasPlugin_exports);
+const esbuildAliasPlugin = (config) => {
+	const alias = config && Object.keys(config);
+	return {
+		name: "path-alias",
+		setup(build) {
+			if (!alias || !alias.length) {
+				return;
+			}
+			const main = (k, args) => {
+				const targetPath = config[k].replace(/\/$/, "");
+				return { path: targetPath };
+			};
+			alias.forEach((k) => {
+				build.onResolve({ filter: new RegExp(`^.*${k}$`) }, (args) => {
+					return main(k, args);
+				});
+				build.onResolve({ filter: new RegExp(`^.*\\/${k}\\/.*$`) }, (args) => {
+					return main(k, args);
+				});
+			});
+		}
+	};
+};

package/dist/cjs/extractor/esbuildTsconfigPaths.cjs

@@ -0,0 +1,92 @@
+
+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 name2 in all) __defProp(target, name2, {
+		get: all[name2],
+		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 esbuildTsconfigPaths_exports = {};
+__export(esbuildTsconfigPaths_exports, {
+	TsconfigPathsPlugin: () => TsconfigPathsPlugin,
+	loadCompilerOptionsFromTsconfig: () => loadCompilerOptionsFromTsconfig
+});
+module.exports = __toCommonJS(esbuildTsconfigPaths_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_typescript = require("typescript");
+const name = "tsconfig-paths";
+function TsconfigPathsPlugin() {
+	const compilerOptions = loadCompilerOptionsFromTsconfig();
+	return {
+		name,
+		setup({ onResolve }) {
+			onResolve({ filter: /.*/ }, (args) => {
+				if (args.path.startsWith("@tamagui/")) {
+					return null;
+				}
+				const paths = compilerOptions.paths || {};
+				const hasMatchingPath = Object.keys(paths).some((p) => new RegExp(p.replace("*", "\\w*")).test(args.path));
+				if (!hasMatchingPath) {
+					return null;
+				}
+				const { resolvedModule } = (0, import_typescript.nodeModuleNameResolver)(args.path, args.importer, compilerOptions, import_typescript.sys);
+				if (!resolvedModule) {
+					return null;
+				}
+				const { resolvedFileName } = resolvedModule;
+				if (!resolvedFileName || resolvedFileName.endsWith(".d.ts")) {
+					return null;
+				}
+				return { path: resolvedFileName };
+			});
+		}
+	};
+}
+function loadCompilerOptionsFromTsconfig(tsconfig) {
+	if (!tsconfig) {
+		const configPath = (0, import_typescript.findConfigFile)(process.cwd(), import_typescript.sys.fileExists, "tsconfig.json") || (0, import_typescript.findConfigFile)(process.cwd(), import_typescript.sys.fileExists, "jsconfig.json");
+		if (configPath) {
+			return parseTsconfig(configPath);
+		}
+		return {};
+	}
+	if (typeof tsconfig === "string") {
+		if (import_node_fs.default.existsSync(tsconfig)) {
+			return parseTsconfig(tsconfig);
+		} else {
+			throw new Error(`Specified tsconfig file not found: ${tsconfig}`);
+		}
+	}
+	const baseDir = process.cwd();
+	const parsed = (0, import_typescript.parseJsonConfigFileContent)(tsconfig, import_typescript.sys, baseDir);
+	return parsed.options;
+}
+function parseTsconfig(configFilePath) {
+	const configFile = (0, import_typescript.readConfigFile)(configFilePath, import_typescript.sys.readFile);
+	if (configFile.error) {
+		throw new Error(`Error reading tsconfig file '${configFilePath}': ${configFile.error.messageText}`);
+	}
+	const baseDir = import_node_path.default.dirname(configFilePath);
+	const parsed = (0, import_typescript.parseJsonConfigFileContent)(configFile.config, import_typescript.sys, baseDir);
+	return parsed.options;
+}

package/dist/cjs/extractor/getTamaguiConfigPathFromOptionsConfig.cjs

@@ -0,0 +1,38 @@
+
+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 getTamaguiConfigPathFromOptionsConfig_exports = {};
+__export(getTamaguiConfigPathFromOptionsConfig_exports, { getTamaguiConfigPathFromOptionsConfig: () => getTamaguiConfigPathFromOptionsConfig });
+module.exports = __toCommonJS(getTamaguiConfigPathFromOptionsConfig_exports);
+var import_node_path = require("node:path");
+var import_node_fs = require("node:fs");
+function getTamaguiConfigPathFromOptionsConfig(config, root = process.cwd()) {
+	if ((0, import_node_path.isAbsolute)(config)) {
+		return config;
+	}
+	const fullPath = (0, import_node_path.join)(root, config);
+	try {
+		if ((0, import_node_fs.statSync)(fullPath).isFile()) {
+			return fullPath;
+		}
+	} catch {}
+	return (0, import_node_path.resolve)(config);
+}

package/dist/cjs/extractor/loadTamagui.cjs

@@ -0,0 +1,344 @@
+
+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 loadTamagui_exports = {};
+__export(loadTamagui_exports, {
+	esbuildWatchFiles: () => esbuildWatchFiles,
+	generateThemesAndLog: () => generateThemesAndLog,
+	getOptions: () => getOptions,
+	getTamaguiBuildConfigDependencies: () => getTamaguiBuildConfigDependencies,
+	loadTamagui: () => loadTamagui,
+	loadTamaguiBuildConfigAsync: () => loadTamaguiBuildConfigAsync,
+	loadTamaguiBuildConfigSync: () => loadTamaguiBuildConfigSync,
+	loadTamaguiFromModules: () => loadTamaguiFromModules,
+	loadTamaguiSync: () => loadTamaguiSync,
+	resolveWebOrNativeSpecificEntry: () => resolveWebOrNativeSpecificEntry
+});
+module.exports = __toCommonJS(loadTamagui_exports);
+var import_node_path = require("node:path");
+var import_node_module = require("node:module");
+var import_cli_color = require("@tamagui/cli-color");
+var import_esbuild = __toESM(require("esbuild"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_requireTamaguiCore = require("../helpers/requireTamaguiCore.cjs");
+var import_registerRequire = require("../registerRequire.cjs");
+var import_bundleConfig = require("./bundleConfig.cjs");
+var import_getTamaguiConfigPathFromOptionsConfig = require("./getTamaguiConfigPathFromOptionsConfig.cjs");
+var import_regenerateConfig = require("./regenerateConfig.cjs");
+const nodeRequire = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : {}.url);
+const getFilledOptions = (propsIn) => ({
+	platform: "web",
+	config: "tamagui.config.ts",
+	components: ["tamagui"],
+	...propsIn
+});
+let isLoadingPromise;
+async function loadTamagui(propsIn, rebuild = false) {
+	if (isLoadingPromise) return await isLoadingPromise;
+	isLoadingPromise = (async () => {
+		const props = getFilledOptions(propsIn);
+		const bundleInfo = await (0, import_bundleConfig.getBundledConfig)(props, rebuild);
+		if (!bundleInfo) throw new Error(`[tamagui] The config and component bundle completed without a project result`);
+		await generateThemesAndLog(props, rebuild);
+		const maybeTamaguiConfig = bundleInfo.tamaguiConfig;
+		if (maybeTamaguiConfig && !maybeTamaguiConfig.parsed) {
+			const { createTamagui } = (0, import_requireTamaguiCore.requireTamaguiCore)(props.platform || "web");
+			bundleInfo.tamaguiConfig = createTamagui(bundleInfo.tamaguiConfig);
+		}
+		if (!(0, import_bundleConfig.hasBundledConfigChanged)()) return bundleInfo;
+		await (0, import_regenerateConfig.regenerateConfig)(props, bundleInfo);
+		return bundleInfo;
+	})();
+	try {
+		return await isLoadingPromise;
+	} finally {
+		isLoadingPromise = null;
+	}
+}
+async function loadTamaguiFromModules(propsIn, evaluated) {
+	const props = getFilledOptions(propsIn);
+	await generateThemesAndLog(props);
+	const configModule = evaluated.config;
+	let tamaguiConfig = configModule.default || configModule.config || configModule;
+	if ("config" in tamaguiConfig && tamaguiConfig.config && !("tokens" in tamaguiConfig)) tamaguiConfig = tamaguiConfig.config;
+	if (!tamaguiConfig) throw new Error(`The Vite module runner did not return a valid Tamagui config`);
+	const hostCore = (0, import_requireTamaguiCore.requireTamaguiCore)(props.platform || "web");
+	if (!tamaguiConfig.parsed) tamaguiConfig = hostCore.createTamagui(tamaguiConfig);
+	else hostCore.installTamaguiConfig(tamaguiConfig);
+	(0, import_bundleConfig.setLoadedConfig)(tamaguiConfig);
+	const projectInfo = {
+		components: evaluated.components.map(({ moduleName, module: module2 }) => {
+			(0, import_registerRequire.setRequireResult)(moduleName, module2);
+			return {
+				moduleName,
+				nameToInfo: (0, import_bundleConfig.getComponentStaticConfigByName)(moduleName, module2.default ?? module2)
+			};
+		}),
+		nameToPaths: {},
+		tamaguiConfig,
+		stampSources: evaluated.stampSources
+	};
+	if (props.outputCSS) await (0, import_bundleConfig.writeTamaguiCSS)(props.outputCSS, projectInfo.tamaguiConfig);
+	return projectInfo;
+}
+let waiting = false;
+const generateThemesAndLog = async (options, force = false) => {
+	if (waiting) return;
+	if (!options.themeBuilder) return;
+	try {
+		waiting = true;
+		await new Promise((res) => setTimeout(res, 30));
+		if (await (0, import_regenerateConfig.generateTamaguiThemes)(options, force)) {
+			(0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `  \u27A1 [tamagui] generated themes: ${(0, import_node_path.relative)(options.root || process.cwd(), options.themeBuilder.output)}`);
+			if (options.outputCSS) {
+				const loadedConfig = (0, import_bundleConfig.getLoadedConfig)();
+				if (loadedConfig) await (0, import_bundleConfig.writeTamaguiCSS)(options.outputCSS, loadedConfig);
+			}
+		}
+	} finally {
+		waiting = false;
+	}
+};
+const last = {};
+const lastVersion = {};
+const buildConfigDependencies = /* @__PURE__ */ new WeakMap();
+function getTamaguiBuildConfigDependencies(options) {
+	return buildConfigDependencies.get(options) ?? [];
+}
+async function loadTamaguiBuildConfigAsync(tamaguiOptions) {
+	const buildFilePath = tamaguiOptions?.buildFile ?? "./tamagui.build.ts";
+	const root = tamaguiOptions?.root || process.cwd();
+	const absolutePath = (0, import_node_path.resolve)(root, buildFilePath);
+	if (import_fs_extra.default.existsSync(absolutePath)) try {
+		const result = await import_esbuild.default.build({
+			entryPoints: [absolutePath],
+			absWorkingDir: root,
+			bundle: true,
+			packages: "external",
+			platform: "node",
+			format: "cjs",
+			target: "node18",
+			write: false,
+			metafile: true
+		});
+		const module2 = { exports: {} };
+		const projectRequire = (0, import_node_module.createRequire)(absolutePath);
+		const code = result.outputFiles[0]?.text;
+		if (!code) throw new Error(`No output generated for ${buildFilePath}`);
+		new Function("module", "exports", "require", "process", code)(module2, module2.exports, projectRequire, process);
+		const out = module2.exports.default || module2.exports;
+		if (!out || typeof out !== "object") throw new Error(`No default export found in ${buildFilePath}: ${out}`);
+		const loadedOptions = {
+			...tamaguiOptions,
+			...out
+		};
+		const dependencies2 = Object.keys(result.metafile.inputs).map((input) => (0, import_node_path.resolve)(root, input));
+		buildConfigDependencies.set(loadedOptions, dependencies2);
+		tamaguiOptions = loadedOptions;
+	} catch (err) {
+		console.error(`[tamagui] Error loading ${buildFilePath}:`, err);
+		throw err;
+	}
+	if (!tamaguiOptions) throw new Error(`No tamagui build options found either via input props or at tamagui.build.ts`);
+	const options = {
+		config: "tamagui.config.ts",
+		components: ["tamagui", "@tamagui/core"],
+		...tamaguiOptions
+	};
+	const dependencies = buildConfigDependencies.get(tamaguiOptions);
+	if (dependencies) buildConfigDependencies.set(options, dependencies);
+	return options;
+}
+function loadTamaguiBuildConfigSync(tamaguiOptions) {
+	const buildFilePath = tamaguiOptions?.buildFile ?? "./tamagui.build.ts";
+	const root = tamaguiOptions?.root || process.cwd();
+	const absolutePath = (0, import_node_path.resolve)(root, buildFilePath);
+	if (import_fs_extra.default.existsSync(absolutePath)) {
+		const registered = (0, import_registerRequire.registerRequire)("web", { ignoredModules: tamaguiOptions?.dangerouslyIgnoreStaticEvaluationModules });
+		try {
+			const out = nodeRequire(absolutePath).default;
+			if (!out) throw new Error(`No default export found in ${buildFilePath}: ${out}`);
+			tamaguiOptions = {
+				...tamaguiOptions,
+				...out
+			};
+		} finally {
+			registered.unregister();
+		}
+	}
+	if (!tamaguiOptions) throw new Error(`No tamagui build options found either via input props or at tamagui.build.ts`);
+	return {
+		config: "tamagui.config.ts",
+		components: ["tamagui", "@tamagui/core"],
+		...tamaguiOptions
+	};
+}
+function loadTamaguiSync({ forceExports, cacheKey, ...propsIn }) {
+	const key = JSON.stringify(propsIn);
+	if (last[key] && !(0, import_bundleConfig.hasBundledConfigChanged)()) {
+		if (!lastVersion[key] || lastVersion[key] === cacheKey) return last[key];
+	}
+	lastVersion[key] = cacheKey || "";
+	const props = getFilledOptions(propsIn);
+	const previousIsStatic = process.env.IS_STATIC;
+	const previousIsServer = process.env.TAMAGUI_IS_SERVER;
+	const previousDev = globalThis["__DEV__"];
+	process.env.IS_STATIC = "is_static";
+	process.env.TAMAGUI_IS_SERVER = "true";
+	const { unregister } = (0, import_registerRequire.registerRequire)(props.platform || "web", { ignoredModules: props.dangerouslyIgnoreStaticEvaluationModules });
+	try {
+		globalThis["__DEV__"] = process.env.NODE_ENV === "development";
+		let tamaguiConfig = null;
+		if (propsIn.config) {
+			const configPath = (0, import_getTamaguiConfigPathFromOptionsConfig.getTamaguiConfigPathFromOptionsConfig)(propsIn.config, propsIn.root);
+			const exp = nodeRequire(configPath);
+			if (!exp) throw new Error(`The Tamagui config module did not export a value`);
+			tamaguiConfig = exp["default"] || exp["config"] || exp;
+			if (!tamaguiConfig || !tamaguiConfig.parsed) {
+				const confPath = nodeRequire.resolve(configPath);
+				throw new Error(`Can't find valid config in ${confPath}:
+          
+  Be sure you "export default" or "export const config" the config.`);
+			}
+			if (tamaguiConfig) {
+				const { createTamagui } = (0, import_requireTamaguiCore.requireTamaguiCore)(props.platform || "web");
+				createTamagui(tamaguiConfig);
+			}
+		}
+		const components = (0, import_bundleConfig.loadComponentsSync)(props, forceExports);
+		if (!components) throw new Error(`No components loaded`);
+		if (process.env.DEBUG === "tamagui") console.info(`components`, components);
+		const info = {
+			components,
+			tamaguiConfig,
+			nameToPaths: (0, import_registerRequire.getNameToPaths)()
+		};
+		if (tamaguiConfig) {
+			const { outputCSS } = props;
+			if (outputCSS) (0, import_bundleConfig.writeTamaguiCSS)(outputCSS, tamaguiConfig);
+			(0, import_regenerateConfig.regenerateConfigSync)(props, info);
+		}
+		last[key] = {
+			...info,
+			cached: true
+		};
+		return info;
+	} finally {
+		if (previousIsStatic === void 0) delete process.env.IS_STATIC;
+		else process.env.IS_STATIC = previousIsStatic;
+		if (previousIsServer === void 0) delete process.env.TAMAGUI_IS_SERVER;
+		else process.env.TAMAGUI_IS_SERVER = previousIsServer;
+		globalThis["__DEV__"] = previousDev;
+		unregister();
+	}
+}
+async function getOptions({ root = process.cwd(), tsconfigPath = "tsconfig.json", tamaguiOptions, host, debug } = {}) {
+	const dotDir = (0, import_node_path.join)(root, ".tamagui");
+	let pkgJson = {};
+	try {
+		pkgJson = await import_fs_extra.default.readJSON((0, import_node_path.join)(root, "package.json"));
+	} catch (err) {}
+	return {
+		mode: process.env.NODE_ENV === "production" ? "production" : "development",
+		root,
+		host: host || "127.0.0.1",
+		pkgJson,
+		debug,
+		tsconfigPath,
+		tamaguiOptions: {
+			platform: "web",
+			components: ["tamagui"],
+			...tamaguiOptions,
+			config: tamaguiOptions?.config ?? await getDefaultTamaguiConfigPath(root, tamaguiOptions?.config)
+		},
+		paths: {
+			root,
+			dotDir,
+			conf: (0, import_node_path.join)(dotDir, "tamagui.config.json"),
+			types: (0, import_node_path.join)(dotDir, "types.json")
+		}
+	};
+}
+function resolveWebOrNativeSpecificEntry(entry, platform) {
+	const workspaceRoot = (0, import_node_path.resolve)();
+	const resolved = nodeRequire.resolve(entry, { paths: [workspaceRoot] });
+	const ext = (0, import_node_path.extname)(resolved);
+	const fileName = (0, import_node_path.basename)(resolved).replace(ext, "");
+	const specificExt = (platform || "web") === "web" ? "web" : "native";
+	const specificFile = (0, import_node_path.join)((0, import_node_path.dirname)(resolved), fileName + "." + specificExt + ext);
+	if (import_fs_extra.default.existsSync(specificFile)) return specificFile;
+	return entry;
+}
+const defaultPaths = ["tamagui.config.ts", (0, import_node_path.join)("src", "tamagui.config.ts")];
+let hasWarnedOnce = false;
+async function getDefaultTamaguiConfigPath(root, configPath) {
+	const searchPaths = [...new Set([configPath, ...defaultPaths].filter(Boolean).map((p) => (0, import_node_path.join)(root, p)))];
+	for (const path of searchPaths) if (await import_fs_extra.default.pathExists(path)) return path;
+	if (!hasWarnedOnce) {
+		hasWarnedOnce = true;
+		console.warn(`Warning: couldn't find tamagui.config.ts in the following paths given configuration "${configPath}":
+    ${searchPaths.join(`
+  `)}
+  `);
+	}
+}
+async function esbuildWatchFiles(entry, onChanged) {
+	let hasRunOnce = false;
+	const context = await import_esbuild.default.context({
+		bundle: true,
+		entryPoints: [entry],
+		resolveExtensions: [
+			".ts",
+			".tsx",
+			".js",
+			".mjs"
+		],
+		logLevel: "silent",
+		write: false,
+		alias: {
+			"react-native-web": "@tamagui/react-native-web-lite",
+			"react-native": "@tamagui/react-native-web-lite"
+		},
+		plugins: [{
+			name: `on-rebuild`,
+			setup({ onEnd, onResolve }) {
+				onResolve({ filter: /^[^./]|^\.[^./]|^\.\.[^/]/ }, (args) => ({
+					path: args.path,
+					external: true
+				}));
+				onEnd(() => {
+					if (!hasRunOnce) hasRunOnce = true;
+					else onChanged();
+				});
+			}
+		}]
+	});
+	context.watch();
+	return () => {
+		context.dispose();
+	};
+}