@tamagui/static 2.7.7 → 3.0.0-beta.1093.1

package/dist/cjs/componentDiscovery.cjs

@@ -0,0 +1,94 @@
+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 componentDiscovery_exports = {};
+__export(componentDiscovery_exports, { ComponentDiscovery: () => ComponentDiscovery });
+module.exports = __toCommonJS(componentDiscovery_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_bundleConfig = require("./extractor/bundleConfig.cjs");
+const packageSpecifier = /^(?:@[^/@\s]+\/)?[^./~@\s][^/\s]*(?:\/|$)/;
+function isPackageSpecifier(specifier) {
+	return packageSpecifier.test(specifier);
+}
+var ComponentDiscovery = class {
+	/** null records a module that had no components or could not evaluate */
+	#discovered = /* @__PURE__ */ new Map();
+	clear() {
+		this.#discovered.clear();
+	}
+	/** host-resolved ids of every module discovery found components in */
+	ids() {
+		return [...this.#discovered].filter(([, loaded]) => loaded !== null).map(([id]) => id).sort();
+	}
+	/** re-register everything found so far into a freshly built registry */
+	seed(registry) {
+		for (const [id, loaded] of this.#discovered) {
+			if (!loaded) continue;
+			registry.modulesById.set(id, id);
+			registry.componentsByModule.set(id, loaded);
+		}
+	}
+	async prepare(module2, registry, evaluate) {
+		if (!evaluate) return;
+		const seen = /* @__PURE__ */ new Set();
+		const provenances = [...module2.elements.map((element) => element.component.provenance), ...module2.styledDefinitions.map((definition) => definition.base.provenance)];
+		for (const provenance of provenances) {
+			if (!provenance || !isPackageSpecifier(provenance.specifier)) continue;
+			const id = provenance.resolvedId.split(/[?#]/, 1)[0];
+			if (seen.has(id) || registry.modulesById.has(id) || this.#discovered.has(id)) {
+				continue;
+			}
+			seen.add(id);
+			if (!import_node_path.default.isAbsolute(id)) {
+				this.#discovered.set(id, null);
+				continue;
+			}
+			let loaded = null;
+			try {
+				const exports = await evaluate({
+					id,
+					specifier: provenance.specifier
+				});
+				if (exports) {
+					const nameToInfo = (0, import_bundleConfig.getComponentStaticConfigByName)(id, exports.default ?? exports);
+					if (Object.keys(nameToInfo).length) loaded = {
+						moduleName: id,
+						nameToInfo
+					};
+				}
+			} catch (error) {
+				if (process.env.DEBUG === "tamagui") {
+					console.info(`[tamagui] component discovery skipped ${id}:`, error);
+				}
+			}
+			this.#discovered.set(id, loaded);
+			if (loaded) {
+				registry.modulesById.set(id, id);
+				registry.componentsByModule.set(id, loaded);
+			}
+		}
+	}
+};

package/dist/cjs/constants.cjs

@@ -0,0 +1,32 @@
+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 constants_exports = {};
+__export(constants_exports, {
+	CSS_FILE_NAME: () => CSS_FILE_NAME,
+	FAILED_EVAL: () => FAILED_EVAL,
+	MEDIA_SEP: () => MEDIA_SEP,
+	SHOULD_DEBUG: () => SHOULD_DEBUG
+});
+module.exports = __toCommonJS(constants_exports);
+const CSS_FILE_NAME = "__snack.css";
+const MEDIA_SEP = "_";
+const FAILED_EVAL = /* @__PURE__ */ Symbol("failed_style_eval");
+const SHOULD_DEBUG = process.env.DEBUG === "*" || process.env.DEBUG?.startsWith("tamagui");

package/dist/cjs/domStructuralPass.cjs

@@ -0,0 +1,121 @@
+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 domStructuralPass_exports = {};
+__export(domStructuralPass_exports, { domStructuralPass: () => domStructuralPass });
+module.exports = __toCommonJS(domStructuralPass_exports);
+var import_dom = require("@tamagui/dom");
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_node_crypto = require("node:crypto");
+const DOM_FRONTENDS = /* @__PURE__ */ new Set([
+	"tamagui",
+	"tamagui/dom",
+	"@tamagui/core",
+	"@tamagui/core/dom",
+	"@tamagui/tailwind"
+]);
+const RUNTIME_STYLE_FRONTENDS = /* @__PURE__ */ new Set([
+	"tamagui",
+	"@tamagui/core",
+	"@tamagui/web"
+]);
+const acceptsTag = (accepted, tag) => accepted === "*" || accepted.includes(tag);
+function isDOMElement(element) {
+	const provenance = element.component.provenance;
+	return provenance?.importedName === "html" && DOM_FRONTENDS.has(provenance.specifier);
+}
+const versionHash = (0, import_node_crypto.createHash)("sha256").update(JSON.stringify({
+	ATTRIBUTES: import_dom.ATTRIBUTES,
+	EVENTS: import_dom.EVENTS,
+	NATIVE_BACKING: import_dom.NATIVE_BACKING,
+	TAGS: import_dom.TAGS
+})).digest("hex");
+const domStructuralPass = {
+	versionHash: `dom-structural-v4-${versionHash}`,
+	transform({ module: module2, source, target }) {
+		const edits = [];
+		const diagnostics = [];
+		const domElements = module2.elements.filter(isDOMElement);
+		const supportedDOMElements = domElements.filter((element) => element.component.name in import_dom.TAGS);
+		const domBySpan = new Map(supportedDOMElements.map((element) => [`${element.span.start}:${element.span.end}`, element]));
+		for (const element of domElements) {
+			const tagName = element.component.name;
+			if (!(tagName in import_dom.TAGS)) {
+				diagnostics.push((0, import_compiler_core.localBailout)("local/unsupported-target", element.component.span, `html.${element.component.name} is not part of the Tamagui DOM contract`));
+				continue;
+			}
+			const tag = import_dom.TAGS[tagName];
+			if (target === "native" && tag.native === "none") {
+				diagnostics.push((0, import_compiler_core.localBailout)("local/unsupported-target", element.component.span, `html.${tagName} is not supported on native: ${tag.note ?? "no native backing"}`));
+				continue;
+			}
+			for (const entry of element.entries) {
+				if (entry.kind !== "prop") continue;
+				const attribute = (entry.name in import_dom.ATTRIBUTES ? import_dom.ATTRIBUTES[entry.name] : void 0) ?? (entry.name.startsWith("data-") ? import_dom.ATTRIBUTES["data-*"] : void 0);
+				const event = entry.name in import_dom.EVENTS ? import_dom.EVENTS[entry.name] : void 0;
+				const row = attribute ?? event;
+				if (!row) continue;
+				if (!acceptsTag(row.tags, tagName)) {
+					diagnostics.push((0, import_compiler_core.localBailout)("local/unsupported-prop-key", entry.span, `${entry.name} is not supported on html.${tagName}`));
+					continue;
+				}
+				if (target === "native" && row.native === "none") {
+					if (event) continue;
+					diagnostics.push((0, import_compiler_core.localBailout)("local/unsupported-prop-key", entry.span, `${entry.name} is not supported on native html.${tagName}: ${row.note ?? "no native equivalent"}`));
+				}
+			}
+			for (const entry of element.entries) {
+				if (entry.kind !== "child" || entry.value.kind !== "element") continue;
+				const child = domBySpan.get(`${entry.value.span.start}:${entry.value.span.end}`);
+				if (!child) continue;
+				const childTag = child.component.name;
+				const invalid = tag.content === "void" || tag.content === "text" || tag.content === "phrasing" && import_dom.TAGS[childTag].display === "block" || tag.content === "tags" && !tag.childTags?.includes(childTag);
+				if (invalid) {
+					diagnostics.push((0, import_compiler_core.localBailout)("local/unsupported-child", child.component.span, `html.${childTag} cannot be nested directly inside html.${tagName}`));
+				}
+			}
+		}
+		for (const definition of module2.domStyleDefinitions) {
+			if (definition.value.kind !== "static") {
+				diagnostics.push((0, import_compiler_core.localBailout)("local/dynamic-style-value", definition.value.span, `style() definition ${definition.name} must be statically evaluable`));
+				continue;
+			}
+			const isRuntimeStyle = RUNTIME_STYLE_FRONTENDS.has(definition.factory.specifier);
+			if (isRuntimeStyle && (!definition.value.value || typeof definition.value.value !== "object" || Array.isArray(definition.value.value))) {
+				diagnostics.push((0, import_compiler_core.localBailout)("local/dynamic-style-value", definition.value.span, `style() definition ${definition.name} must be an object literal`));
+				continue;
+			}
+			edits.push({
+				start: definition.span.start,
+				end: definition.span.end,
+				content: isRuntimeStyle ? `({ className: "", [Symbol.for("tamagui.stylePiece")]: { byKey: {}, styleObject: ${JSON.stringify(definition.value.value)} } })` : "undefined",
+				origin: definition.span
+			});
+		}
+		const nextModule = module2;
+		return {
+			module: nextModule,
+			edits,
+			imports: [],
+			diagnostics,
+			dependencies: []
+		};
+	}
+};

package/dist/cjs/exports.cjs

@@ -0,0 +1,44 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var exports_exports = {};
+__export(exports_exports, {
+	clearFormatCache: () => import_detectModuleFormat.clearFormatCache,
+	detectModuleFormat: () => import_detectModuleFormat.detectModuleFormat,
+	esbundleTamaguiConfig: () => import_bundle.esbundleTamaguiConfig,
+	evaluateComponentModule: () => import_bundleConfig.evaluateComponentModule
+});
+module.exports = __toCommonJS(exports_exports);
+__reExport(exports_exports, require("./checkDeps.cjs"), module.exports);
+__reExport(exports_exports, require("./compilerHost.cjs"), module.exports);
+__reExport(exports_exports, require("./compiler.cjs"), module.exports);
+__reExport(exports_exports, require("./types.cjs"), module.exports);
+__reExport(exports_exports, require("./constants.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/concatClassName.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/loadTamagui.cjs"), module.exports);
+var import_bundleConfig = require("./extractor/bundleConfig.cjs");
+__reExport(exports_exports, require("./componentDiscovery.cjs"), module.exports);
+__reExport(exports_exports, require("./extractor/watchTamaguiConfig.cjs"), module.exports);
+__reExport(exports_exports, require("./registerRequire.cjs"), module.exports);
+var import_detectModuleFormat = require("./extractor/detectModuleFormat.cjs");
+var import_bundle = require("./extractor/bundle.cjs");
+__reExport(exports_exports, require("./getPragmaOptions.cjs"), module.exports);
+__reExport(exports_exports, require("./zero/index.cjs"), module.exports);

package/dist/cjs/extractor/addLocalExports.cjs

@@ -0,0 +1,63 @@
+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 addLocalExports_exports = {};
+__export(addLocalExports_exports, { addLocalExports: () => addLocalExports });
+module.exports = __toCommonJS(addLocalExports_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+function declarationName(node) {
+	return (0, import_compiler_core.identifierName)(node ? (0, import_compiler_core.childNode)(node, "id") : null);
+}
+function addLocalExports(source, id) {
+	const program = (0, import_compiler_core.parseModuleAst)(source, id);
+	const usedNames = /* @__PURE__ */ new Set();
+	const candidates = [];
+	for (const statement of (0, import_compiler_core.childNodes)(program, "body")) {
+		if (statement.type === "ExportNamedDeclaration") {
+			for (const specifier of (0, import_compiler_core.childNodes)(statement, "specifiers")) {
+				const exported = (0, import_compiler_core.childNode)(specifier, "exported");
+				const name2 = (0, import_compiler_core.identifierName)(exported);
+				if (name2) usedNames.add(name2);
+			}
+			const declaration2 = (0, import_compiler_core.childNode)(statement, "declaration");
+			if (declaration2?.type === "VariableDeclaration") {
+				for (const declarator of (0, import_compiler_core.childNodes)(declaration2, "declarations")) {
+					const name2 = declarationName(declarator);
+					if (name2) usedNames.add(name2);
+				}
+			} else {
+				const name2 = declarationName(declaration2);
+				if (name2) usedNames.add(name2);
+			}
+			continue;
+		}
+		if (statement.type !== "VariableDeclaration") continue;
+		const declarations = (0, import_compiler_core.childNodes)(statement, "declarations");
+		if (declarations.length !== 1) continue;
+		const declaration = declarations[0];
+		const name = declarationName(declaration);
+		if (!name || !(0, import_compiler_core.childNode)(declaration, "init") || usedNames.has(name)) continue;
+		candidates.push(name);
+	}
+	const names = candidates.filter((name) => !usedNames.has(name));
+	return names.length ? `${source}
+export { ${names.join(", ")} }
+` : source;
+}

package/dist/cjs/extractor/bundle.cjs

@@ -0,0 +1,229 @@
+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 bundle_exports = {};
+__export(bundle_exports, {
+	esbuildIgnoreFilesRegex: () => esbuildIgnoreFilesRegex,
+	esbuildLoaderConfig: () => esbuildLoaderConfig,
+	esbundleTamaguiConfig: () => esbundleTamaguiConfig
+});
+module.exports = __toCommonJS(bundle_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_module = require("node:module");
+var import_esbuild = __toESM(require("esbuild"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_staticEvaluationIgnoredModules = require("../staticEvaluationIgnoredModules.cjs");
+var import_detectModuleFormat = require("./detectModuleFormat.cjs");
+var import_esbuildAliasPlugin = require("./esbuildAliasPlugin.cjs");
+var import_loadTamagui = require("./loadTamagui.cjs");
+var import_esbuildTsconfigPaths = require("./esbuildTsconfigPaths.cjs");
+const import_meta = {};
+const nodeRequire = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+const esbuildLoaderConfig = {
+	".js": "jsx",
+	".png": "dataurl",
+	".jpg": "dataurl",
+	".jpeg": "dataurl",
+	".svg": "dataurl",
+	".gif": "dataurl",
+	".webp": "dataurl",
+	".woff2": "dataurl",
+	".woff": "dataurl",
+	".eot": "dataurl",
+	".otf": "dataurl",
+	".ttf": "dataurl",
+	".mp4": "file",
+	".mpeg4": "file",
+	".mov": "file",
+	".avif": "file",
+	".wmv": "file",
+	".webm": "file",
+	".wav": "file",
+	".aac": "file",
+	".ogg": "file",
+	".flac": "file",
+	".node": "empty"
+};
+const dataExtensions = Object.keys(esbuildLoaderConfig).filter((k) => esbuildLoaderConfig[k] === "file" || esbuildLoaderConfig[k] === "dataurl").map((k) => k.slice(1));
+const esbuildIgnoreFilesRegex = new RegExp(`.(${dataExtensions.join("|")})$`, "i");
+function getESBuildConfig({ entryPoints, resolvePlatformSpecificEntries, dangerouslyIgnoreStaticEvaluationModules = [], define: callerDefine, ...options }, platform, aliases) {
+	if (process.env.DEBUG?.startsWith("tamagui")) {
+		console.info(`Building`, entryPoints);
+	}
+	const resolvedEntryPoints = !resolvePlatformSpecificEntries ? entryPoints : entryPoints.map((entry) => (0, import_loadTamagui.resolveWebOrNativeSpecificEntry)(entry, platform));
+	const detectedFormat = options.format || detectEntryFormat(resolvedEntryPoints[0]);
+	const platformDefines = platform === "web" ? {
+		"process.env.TAMAGUI_TARGET": "\"web\"",
+		"process.env.EXPO_OS": "\"web\""
+	} : { "process.env.TAMAGUI_TARGET": "\"native\"" };
+	const res = {
+		bundle: true,
+		entryPoints: resolvedEntryPoints,
+		format: detectedFormat,
+		define: {
+			...platformDefines,
+			...callerDefine
+		},
+		...platform === "native" ? {
+			conditions: ["react-native"],
+			mainFields: [
+				"react-native",
+				"module",
+				"main"
+			]
+		} : {},
+		...detectedFormat === "esm" ? {
+			...platform === "web" ? { mainFields: ["module", "main"] } : {},
+			banner: { js: "import { createRequire as __cr } from \"module\"; const require = __cr(import.meta.url);" }
+		} : {},
+		target: "node24",
+		jsx: "transform",
+		jsxFactory: "react",
+		allowOverwrite: true,
+		keepNames: true,
+		resolveExtensions: [
+			...platform === "web" ? [
+				".web.tsx",
+				".web.ts",
+				".web.jsx",
+				".web.js"
+			] : [
+				".native.tsx",
+				".native.ts",
+				".native.jsx",
+				".native.js"
+			],
+			".tsx",
+			".ts",
+			".jsx",
+			".js"
+		],
+		platform: "node",
+		tsconfigRaw: { compilerOptions: { jsx: "react-jsx" } },
+		loader: esbuildLoaderConfig,
+		logLevel: "warning",
+		plugins: [
+			(0, import_esbuildTsconfigPaths.TsconfigPathsPlugin)(),
+			(0, import_staticEvaluationIgnoredModules.staticEvaluationIgnorePlugin)(dangerouslyIgnoreStaticEvaluationModules),
+			{
+				name: "handle-esm-features",
+				setup(build) {
+					const isCjs = build.initialOptions.format === "cjs" || !build.initialOptions.format;
+					build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs)$/ }, (args) => {
+						if (!isCjs) {
+							return null;
+						}
+						if (args.path.includes("node_modules") && !args.path.includes("@tamagui")) {
+							return null;
+						}
+						let contents = (0, import_node_fs.readFileSync)(args.path, "utf8");
+						let modified = false;
+						if (contents.includes("import.meta.env")) {
+							contents = contents.replace(/import\.meta\.env/g, "process.env");
+							modified = true;
+						}
+						if (contents.includes("import.meta.url")) {
+							contents = contents.replace(/import\.meta\.url/g, "\"\"");
+							modified = true;
+						}
+						if (contents.includes("import.meta.main")) {
+							contents = contents.replace(/import\.meta\.main/g, "false");
+							modified = true;
+						}
+						if (modified) {
+							return {
+								contents,
+								loader: args.path.endsWith(".tsx") ? "tsx" : args.path.endsWith(".ts") ? "ts" : args.path.endsWith(".jsx") ? "jsx" : "js"
+							};
+						}
+						return null;
+					});
+				}
+			},
+			{
+				name: "external",
+				setup(build) {
+					build.onResolve({ filter: /^@tamagui\/(core|web)$/ }, (args) => {
+						if (args.kind === "entry-point") {
+							return null;
+						}
+						return {
+							path: platform === "native" ? "@tamagui/core/native" : args.path,
+							external: true
+						};
+					});
+					build.onResolve({ filter: /react-native\/package.json$/ }, () => {
+						return {
+							path: "react-native/package.json",
+							external: true
+						};
+					});
+					build.onResolve({ filter: /^(react-native|react-native\/.*)$/ }, (args) => {
+						return {
+							path: args.path.replace(/^react-native/, "@tamagui/react-native-web-lite"),
+							external: true
+						};
+					});
+					build.onResolve({ filter: /^(framer-motion|motion)/ }, (args) => {
+						return {
+							path: args.path,
+							external: true
+						};
+					});
+				}
+			},
+			(0, import_esbuildAliasPlugin.esbuildAliasPlugin)({ ...aliases })
+		],
+		...options
+	};
+	return res;
+}
+function detectEntryFormat(entryPoint) {
+	if (entryPoint.startsWith("/") || entryPoint.startsWith(".")) {
+		return (0, import_detectModuleFormat.detectModuleFormat)(entryPoint);
+	}
+	try {
+		const pkgJsonPath = nodeRequire.resolve(entryPoint + "/package.json");
+		const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgJsonPath, "utf-8"));
+		return pkg.type === "module" ? "esm" : "cjs";
+	} catch {
+		return "cjs";
+	}
+}
+async function esbundleTamaguiConfig(props, platform, aliases) {
+	const config = getESBuildConfig(props, platform, aliases);
+	const tmpFile = `${props.outfile}.tmp.${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+	const result = await import_esbuild.default.build({
+		...config,
+		outfile: tmpFile
+	}).catch(async (err) => {
+		await import_fs_extra.default.remove(tmpFile).catch(() => {});
+		throw err;
+	});
+	await import_fs_extra.default.rename(tmpFile, props.outfile);
+	return result;
+}