@tamagui/compiler-core 0.0.0-bootstrap.0 → 3.0.0-beta.637.1

package/dist/cjs/output.cjs

@@ -0,0 +1,149 @@
+
+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 output_exports = {};
+__export(output_exports, {
+	applyLoweredModule: () => applyLoweredModule,
+	sourceContentHash: () => sourceContentHash,
+	validateSourceEdits: () => validateSourceEdits
+});
+module.exports = __toCommonJS(output_exports);
+var import_gen_mapping = require("@jridgewell/gen-mapping");
+var import_magic_string = __toESM(require("magic-string"), 1);
+var import_hash = require("./hash.cjs");
+function compareEdits(left, right) {
+	return left.start - right.start || left.end - right.end || left.index - right.index;
+}
+function sourceContentHash(source) {
+	return (0, import_hash.contentHash)(source);
+}
+function validateSourceEdits(source, edits) {
+	const sorted = edits.map((edit, index) => ({
+		...edit,
+		index
+	})).sort(compareEdits);
+	let previousEnd = 0;
+	for (const edit of sorted) {
+		if (!Number.isInteger(edit.start) || !Number.isInteger(edit.end) || edit.start < 0 || edit.end < edit.start || edit.end > source.length) {
+			throw new Error(`Invalid UTF-16 source edit [${edit.start}, ${edit.end})`);
+		}
+		if (edit.start < previousEnd) {
+			throw new Error(`Overlapping UTF-16 source edit at ${edit.start}`);
+		}
+		previousEnd = Math.max(previousEnd, edit.end);
+	}
+}
+function sourcePositions(source) {
+	const positions = new Array(source.length + 1);
+	let line = 0;
+	let column = 0;
+	for (let index = 0; index <= source.length; index++) {
+		positions[index] = {
+			line,
+			column
+		};
+		if (index === source.length) break;
+		if (source.charCodeAt(index) === 10) {
+			line++;
+			column = 0;
+		} else {
+			column++;
+		}
+	}
+	return positions;
+}
+function mappedSourceMap(source, id, edits) {
+	const map = new import_gen_mapping.GenMapping();
+	(0, import_gen_mapping.setSourceContent)(map, id, source);
+	const positions = sourcePositions(source);
+	let generatedLine = 0;
+	let generatedColumn = 0;
+	let sourceCursor = 0;
+	const emit = (content, sourceStart, sourceEnd) => {
+		const available = Math.max(1, sourceEnd - sourceStart);
+		for (let offset = 0; offset < content.length; offset++) {
+			const originalIndex = Math.min(sourceStart + offset, sourceStart + available - 1);
+			const original = positions[originalIndex];
+			(0, import_gen_mapping.addSegment)(map, generatedLine, generatedColumn, id, original.line, original.column);
+			if (content.charCodeAt(offset) === 10) {
+				generatedLine++;
+				generatedColumn = 0;
+			} else {
+				generatedColumn++;
+			}
+		}
+	};
+	for (const edit of edits) {
+		emit(source.slice(sourceCursor, edit.start), sourceCursor, edit.start);
+		if (edit.origin.id !== id) {
+			throw new Error(`Source edit for ${id} must use a local mapping origin`);
+		}
+		emit(edit.content, edit.origin.start, edit.start === edit.end ? edit.origin.start + 1 : edit.origin.end);
+		sourceCursor = edit.end;
+	}
+	emit(source.slice(sourceCursor), sourceCursor, source.length);
+	const encoded = (0, import_gen_mapping.toEncodedMap)(map);
+	return {
+		version: 3,
+		file: encoded.file ?? void 0,
+		names: encoded.names,
+		sources: encoded.sources,
+		sourcesContent: encoded.sourcesContent ?? [source],
+		mappings: encoded.mappings
+	};
+}
+function applyLoweredModule(source, id, plan) {
+	if (plan.id !== id) {
+		throw new Error(`Lowered module plan ${plan.id} cannot be applied to ${id}`);
+	}
+	if (plan.sourceHash !== sourceContentHash(source)) {
+		throw new Error(`Lowered module plan for ${id} does not match the supplied source`);
+	}
+	if (plan.edits.length === 0) return {
+		changed: false,
+		code: source,
+		map: null
+	};
+	validateSourceEdits(source, plan.edits);
+	const output = new import_magic_string.default(source);
+	const sorted = plan.edits.map((edit, index) => ({
+		...edit,
+		index
+	})).sort(compareEdits);
+	for (const edit of sorted) {
+		if (edit.start === edit.end) {
+			output.appendLeft(edit.start, edit.content);
+		} else {
+			output.overwrite(edit.start, edit.end, edit.content);
+		}
+	}
+	return {
+		changed: true,
+		code: output.toString(),
+		map: mappedSourceMap(source, id, sorted)
+	};
+}

package/dist/cjs/planCache.cjs

@@ -0,0 +1,224 @@
+
+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 planCache_exports = {};
+__export(planCache_exports, {
+	JsonFileCache: () => JsonFileCache,
+	ModulePlanCache: () => ModulePlanCache,
+	PLAN_CACHE_MAX_ENTRIES: () => PLAN_CACHE_MAX_ENTRIES,
+	PLAN_CACHE_SCHEMA_VERSION: () => PLAN_CACHE_SCHEMA_VERSION,
+	defaultPlanCacheRoot: () => defaultPlanCacheRoot,
+	moduleClosureDigest: () => moduleClosureDigest,
+	moduleClosureNode: () => moduleClosureNode,
+	planCacheKey: () => planCacheKey,
+	tamaguiCacheRoot: () => tamaguiCacheRoot
+});
+module.exports = __toCommonJS(planCache_exports);
+var import_node_crypto = require("node:crypto");
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_hash = require("./hash.cjs");
+var import_lower = require("./lower.cjs");
+var import_graph = require("./graph.cjs");
+const PLAN_CACHE_SCHEMA_VERSION = 1;
+const PLAN_CACHE_MAX_ENTRIES = 2e4;
+function tamaguiCacheRoot(projectRoot) {
+	return (0, import_node_path.join)(projectRoot, "node_modules", ".cache", "tamagui");
+}
+function defaultPlanCacheRoot(projectRoot, target) {
+	return (0, import_node_path.join)(tamaguiCacheRoot(projectRoot), "plans", target);
+}
+function moduleClosureNode(input) {
+	return {
+		contentHash: (0, import_graph.moduleContentHash)(input),
+		dependencies: input.imports.filter(({ external }) => !external).map(({ resolvedId }) => resolvedId)
+	};
+}
+function moduleClosureDigest(id, lookup, memo) {
+	const cached = memo?.get(id);
+	if (cached !== void 0) return cached;
+	const reached = /* @__PURE__ */ new Map();
+	const queue = [id];
+	let complete = true;
+	while (queue.length) {
+		const current = queue.pop();
+		if (reached.has(current)) continue;
+		const node = lookup(current);
+		if (!node) {
+			complete = false;
+			break;
+		}
+		reached.set(current, node.contentHash);
+		for (const dependency of node.dependencies) queue.push(dependency);
+	}
+	const digest = complete ? (0, import_hash.contentHash)([...reached].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([current, hash]) => `${current}\0${hash}`).join("\0")) : null;
+	memo?.set(id, digest);
+	return digest;
+}
+function planCacheKey(identity, id, closureDigest) {
+	return (0, import_hash.contentHash)((0, import_hash.stableStringify)({
+		schema: PLAN_CACHE_SCHEMA_VERSION,
+		plan: import_lower.LOWERED_MODULE_PLAN_VERSION,
+		stamp: identity.stamp,
+		target: identity.target,
+		structuralPassHash: identity.structuralPassHash,
+		id,
+		closureDigest
+	}));
+}
+var JsonFileCache = class {
+	constructor(root, schemaVersion, maxEntries = PLAN_CACHE_MAX_ENTRIES) {
+		this.root = root;
+		this.schemaVersion = schemaVersion;
+		this.maxEntries = maxEntries;
+	}
+	root;
+	schemaVersion;
+	maxEntries;
+	#hits = 0;
+	#misses = 0;
+	#writes = 0;
+	#writesSincePrune = 0;
+	#prunedThisProcess = false;
+	#created = /* @__PURE__ */ new Set();
+	get stats() {
+		return {
+			hits: this.#hits,
+			misses: this.#misses,
+			writes: this.#writes
+		};
+	}
+	resetStats() {
+		this.#hits = 0;
+		this.#misses = 0;
+		this.#writes = 0;
+	}
+	#path(key) {
+		return (0, import_node_path.join)(this.root, `v${this.schemaVersion}`, key.slice(0, 2), `${key}.json`);
+	}
+	/**
+	* Null on anything short of an entry `validate` fully accepts. A miss
+	* recompiles; nothing here repairs or partially trusts an entry, and a later
+	* successful compile overwrites the bad file.
+	*/
+	async read(key, validate) {
+		let parsed;
+		try {
+			parsed = JSON.parse(await (0, import_promises.readFile)(this.#path(key), "utf8"));
+		} catch {
+			this.#misses++;
+			return null;
+		}
+		const entry = validate(parsed);
+		if (entry === null) {
+			this.#misses++;
+			return null;
+		}
+		this.#hits++;
+		return entry;
+	}
+	async write(key, value) {
+		const path = this.#path(key);
+		const directory = (0, import_node_path.dirname)(path);
+		if (!this.#created.has(directory)) {
+			await (0, import_promises.mkdir)(directory, { recursive: true });
+			this.#created.add(directory);
+		}
+		const temporaryPath = `${path}.${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}.tmp`;
+		await (0, import_promises.writeFile)(temporaryPath, `${(0, import_hash.stableStringify)(value)}
+`, "utf8");
+		await (0, import_promises.rename)(temporaryPath, path);
+		this.#writes++;
+		this.#writesSincePrune++;
+		const batch = Math.max(1, Math.floor(this.maxEntries / 4));
+		if (!this.#prunedThisProcess || this.#writesSincePrune >= batch) {
+			this.#prunedThisProcess = true;
+			this.#writesSincePrune = 0;
+			await this.#prune();
+		}
+	}
+	/**
+	* Drops the oldest entries once the store exceeds its cap, oldest by the later
+	* of read and write time so an entry a build keeps hitting is not treated as
+	* dead on filesystems that maintain access times.
+	*/
+	async #prune() {
+		const versionRoot = (0, import_node_path.join)(this.root, `v${this.schemaVersion}`);
+		let shards;
+		try {
+			shards = await (0, import_promises.readdir)(versionRoot);
+		} catch {
+			return;
+		}
+		const paths = [];
+		for (const shard of shards) {
+			const directory = (0, import_node_path.join)(versionRoot, shard);
+			let files;
+			try {
+				files = await (0, import_promises.readdir)(directory);
+			} catch {
+				continue;
+			}
+			for (const file of files) {
+				if (file.endsWith(".json")) paths.push((0, import_node_path.join)(directory, file));
+			}
+		}
+		if (paths.length <= this.maxEntries) return;
+		const entries = [];
+		for (const path of paths) {
+			try {
+				const stats = await (0, import_promises.stat)(path);
+				entries.push({
+					path,
+					usedAt: Math.max(stats.atimeMs, stats.mtimeMs)
+				});
+			} catch {}
+		}
+		entries.sort((left, right) => left.usedAt - right.usedAt);
+		for (const entry of entries.slice(0, Math.max(0, entries.length - this.maxEntries))) {
+			await (0, import_promises.unlink)(entry.path).catch(() => {});
+		}
+	}
+};
+var ModulePlanCache = class {
+	constructor(root) {
+		this.root = root;
+		this.#files = new JsonFileCache(root, PLAN_CACHE_SCHEMA_VERSION);
+	}
+	root;
+	#files;
+	get stats() {
+		return this.#files.stats;
+	}
+	resetStats() {
+		this.#files.resetStats();
+	}
+	read(key, id, closureDigest) {
+		return this.#files.read(key, (value) => {
+			const entry = value;
+			const plan = entry?.plan;
+			return entry?.schemaVersion === PLAN_CACHE_SCHEMA_VERSION && entry.moduleId === id && entry.closureDigest === closureDigest && plan && plan.version === import_lower.LOWERED_MODULE_PLAN_VERSION && plan.id === id && typeof plan.sourceHash === "string" && typeof plan.css === "string" && Array.isArray(plan.edits) && Array.isArray(plan.diagnostics) && Array.isArray(plan.dependencies) && !!plan.stats ? entry : null;
+		});
+	}
+	write(key, entry) {
+		return this.#files.write(key, entry);
+	}
+};

package/dist/cjs/session.cjs

@@ -0,0 +1,119 @@
+
+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 session_exports = {};
+__export(session_exports, { CompilerSession: () => CompilerSession });
+module.exports = __toCommonJS(session_exports);
+var import_graph = require("./graph.cjs");
+var import_lower = require("./lower.cjs");
+var import_materialize = require("./materialize.cjs");
+var import_output = require("./output.cjs");
+var import_planCache = require("./planCache.cjs");
+var import_yuku = require("./yuku.cjs");
+function compareIds(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+var CompilerSession = class {
+	#graph = new import_graph.ProjectGraph(import_yuku.yukuFactory, { modules: [] });
+	#queue = Promise.resolve();
+	compile(input) {
+		const operation = this.#queue.then(() => this.#compile(input));
+		this.#queue = operation.catch(() => void 0);
+		return operation;
+	}
+	update(module2) {
+		return this.#enqueue(() => this.#graph.updateModule(module2).invalidatedIds);
+	}
+	has(id) {
+		return this.#graph.contentHash(id) !== null;
+	}
+	dependentsOf(id) {
+		return this.#graph.dependentsOf(id);
+	}
+	remove(id) {
+		return this.#enqueue(() => this.#graph.removeModule(id));
+	}
+	parseCount(id) {
+		return this.#graph.parseCount(id);
+	}
+	#enqueue(operation) {
+		const queued = this.#queue.then(operation);
+		this.#queue = queued.catch(() => void 0);
+		return queued;
+	}
+	async #compile({ module: module2, adapter, structuralPass }) {
+		const invalidated = /* @__PURE__ */ new Set();
+		await this.#install(module2, adapter, /* @__PURE__ */ new Set(), invalidated);
+		const graph = this.#graph;
+		const cache = adapter.planCache?.stamp ? adapter.planCache : null;
+		const closureDigest = cache ? (0, import_planCache.moduleClosureDigest)(module2.id, (id) => {
+			const hash = graph.contentHash(id);
+			return hash ? {
+				contentHash: hash,
+				dependencies: graph.dependenciesOf(id)
+			} : null;
+		}) : null;
+		const entry = cache && closureDigest ? {
+			store: cache.store,
+			digest: closureDigest,
+			key: (0, import_planCache.planCacheKey)({
+				stamp: cache.stamp,
+				target: adapter.target,
+				structuralPassHash: structuralPass?.versionHash ?? `${adapter.target}-noop-v1`
+			}, module2.id, closureDigest)
+		} : null;
+		const cached = entry ? await entry.store.read(entry.key, module2.id, entry.digest) : null;
+		const plan = cached?.plan ?? (0, import_lower.lowerModule)({
+			module: (0, import_materialize.materializeModule)(graph, module2.id),
+			source: module2.source,
+			target: adapter.target,
+			host: adapter.host,
+			options: { projectGeneration: adapter.projectGeneration },
+			structuralPass
+		});
+		if (entry && !cached) {
+			await entry.store.write(entry.key, {
+				schemaVersion: import_planCache.PLAN_CACHE_SCHEMA_VERSION,
+				moduleId: module2.id,
+				closureDigest: entry.digest,
+				plan
+			});
+		}
+		return {
+			plan,
+			output: (0, import_output.applyLoweredModule)(module2.source, module2.id, plan),
+			invalidatedIds: [...invalidated].sort(compareIds)
+		};
+	}
+	async #install(module2, adapter, visited, invalidated) {
+		if (visited.has(module2.id)) return;
+		visited.add(module2.id);
+		for (const dependency of module2.imports) {
+			if (dependency.external || this.has(dependency.resolvedId)) continue;
+			const loaded = await adapter.load(dependency.resolvedId);
+			if (loaded) {
+				await this.#install(loaded, adapter, visited, invalidated);
+			}
+		}
+		const update = this.#graph.updateModule(module2);
+		for (const id of update.invalidatedIds) invalidated.add(id);
+	}
+};

package/dist/cjs/yuku.cjs

@@ -0,0 +1,159 @@
+
+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 yuku_exports = {};
+__export(yuku_exports, {
+	parseModuleAst: () => parseModuleAst,
+	yukuFactory: () => yukuFactory
+});
+module.exports = __toCommonJS(yuku_exports);
+var import_yuku_analyzer = require("yuku-analyzer");
+var import_contracts = require("./contracts.cjs");
+var import_ast = require("./ast.cjs");
+var import_normalize = require("./normalize.cjs");
+var YukuCandidate = class {
+	constructor(project) {
+		this.project = project;
+		this.#analyzer = new import_yuku_analyzer.Analyzer({ resolve: (specifier, importer) => (0, import_contracts.resolveFromHost)(this.project.resolutions, specifier, importer) });
+		for (const [id, source] of project.files) this.addFile(id, source);
+	}
+	project;
+	name = "yuku";
+	#analyzer;
+	#parseCounts = /* @__PURE__ */ new Map();
+	addFile(id, source) {
+		this.#analyzer.addFile(id, source, {
+			preserveParens: true,
+			sourceType: "module"
+		});
+		this.#parseCounts.set(id, (this.#parseCounts.get(id) ?? 0) + 1);
+	}
+	removeFile(id) {
+		return this.#analyzer.removeFile(id);
+	}
+	link() {
+		this.#analyzer.link();
+	}
+	#module(id) {
+		const module2 = this.#analyzer.module(id);
+		if (!module2) throw new Error(`yuku: unknown module ${id}`);
+		return module2;
+	}
+	#canonicalSymbol(id, localName) {
+		const symbol = this.#module(id).resolve(localName);
+		return symbol ? this.#analyzer.definitionOf(symbol)?.symbol ?? null : null;
+	}
+	definitionOf(id, localName) {
+		const symbol = this.#canonicalSymbol(id, localName);
+		if (!symbol) return null;
+		const declaration = symbol.declarations[0];
+		if (!declaration) return null;
+		const program = (0, import_normalize.asAstNode)(symbol.module.ast, `${symbol.module.path} program`);
+		const normalizedDeclaration = (0, import_normalize.declarationForName)(program, symbol.name) ?? (0, import_normalize.asAstNode)(declaration, `${symbol.name} declaration`);
+		return (0, import_normalize.definitionFromDeclaration)(symbol.module.path, symbol.name, program, normalizedDeclaration);
+	}
+	referencesOf(definition) {
+		const symbol = this.#canonicalSymbol(definition.id, definition.name);
+		if (!symbol) return [];
+		return this.#analyzer.referencesOf(symbol).map(({ module: module2, reference }) => ({
+			id: (0, import_contracts.resolvedModuleId)(module2.path),
+			name: reference.name,
+			start: reference.node.start,
+			end: reference.node.end
+		}));
+	}
+	dependenciesOf(id) {
+		return this.#module(id).dependencies.map((module2) => module2.path).sort();
+	}
+	dependentsOf(id) {
+		return this.#module(id).dependents.map((module2) => module2.path).sort();
+	}
+	affectedBy(id) {
+		const affected = /* @__PURE__ */ new Set([id]);
+		const queue = [id];
+		while (queue.length) {
+			const current = queue.shift();
+			for (const dependent of this.dependentsOf(current)) {
+				if (!affected.has(dependent)) {
+					affected.add(dependent);
+					queue.push(dependent);
+				}
+			}
+		}
+		return [...affected].sort();
+	}
+	programOf(id) {
+		return (0, import_normalize.asAstNode)(this.#module(id).ast, `${id} program`);
+	}
+	sourceOf(id) {
+		return this.#module(id).source;
+	}
+	parseCount(id) {
+		return this.#parseCounts.get(id) ?? 0;
+	}
+	diagnostics() {
+		const parseDiagnostics = [...this.#analyzer.modules.values()].flatMap((module2) => module2.diagnostics.map((diagnostic) => ({
+			kind: "parse",
+			id: (0, import_contracts.resolvedModuleId)(module2.path),
+			message: diagnostic.message
+		})));
+		return [...parseDiagnostics, ...this.#analyzer.diagnostics.map((diagnostic) => ({
+			kind: "link",
+			id: (0, import_contracts.resolvedModuleId)(diagnostic.module),
+			message: diagnostic.message
+		}))];
+	}
+};
+const yukuFactory = {
+	name: "yuku",
+	create: (project) => new YukuCandidate(project),
+	scanImports(id, source) {
+		const candidate = new YukuCandidate({
+			files: /* @__PURE__ */ new Map([[id, source]]),
+			resolutions: /* @__PURE__ */ new Map()
+		});
+		const found = [];
+		(0, import_ast.walkAst)(candidate.programOf(id), (node) => {
+			if (node.type !== "ImportDeclaration" && node.type !== "ExportNamedDeclaration" && node.type !== "ExportAllDeclaration" && node.type !== "ImportExpression") {
+				return;
+			}
+			const sourceNode = (0, import_ast.childNode)(node, "source");
+			if (sourceNode && typeof sourceNode.value === "string") {
+				found.push({
+					start: node.start,
+					specifier: sourceNode.value
+				});
+			}
+		});
+		return [...new Set(found.sort((left, right) => left.start - right.start).map(({ specifier }) => specifier))];
+	}
+};
+function parseModuleAst(source, id = "/tamagui/compiler-module.tsx") {
+	const candidate = yukuFactory.create({
+		files: /* @__PURE__ */ new Map([[id, source]]),
+		resolutions: /* @__PURE__ */ new Map()
+	});
+	const diagnostics = candidate.diagnostics().filter((diagnostic) => diagnostic.kind === "parse");
+	if (diagnostics.length) {
+		throw new Error(`Unable to parse ${id}: ${diagnostics.map(({ message }) => message).join("; ")}`);
+	}
+	return candidate.programOf(id);
+}