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

package/dist/cjs/graph.cjs

@@ -0,0 +1,335 @@
+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 graph_exports = {};
+__export(graph_exports, {
+	ProjectGraph: () => ProjectGraph,
+	moduleContentHash: () => moduleContentHash
+});
+module.exports = __toCommonJS(graph_exports);
+var import_node_crypto = require("node:crypto");
+var import_contracts = require("./contracts.cjs");
+var import_ast = require("./ast.cjs");
+var import_diagnostics = require("./diagnostics.cjs");
+var import_evaluate = require("./evaluate.cjs");
+var import_normalize = require("./normalize.cjs");
+function compareIds(left, right) {
+	return compareCodeUnits(left, right);
+}
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function stableImports(imports) {
+	return [...imports].sort((left, right) => {
+		const bySpecifier = compareCodeUnits(left.specifier, right.specifier);
+		return bySpecifier || compareCodeUnits(left.resolvedId, right.resolvedId);
+	});
+}
+function moduleContentHash(input) {
+	const hash = (0, import_node_crypto.createHash)("sha256");
+	hash.update(input.source);
+	hash.update("\0");
+	for (const dependency of stableImports(input.imports)) {
+		hash.update(dependency.specifier);
+		hash.update("\0");
+		hash.update(dependency.resolvedId);
+		hash.update("\0");
+		hash.update(dependency.external ? "external" : "internal");
+		hash.update("\0");
+	}
+	return hash.digest("hex");
+}
+var ProjectGraph = class {
+	#files = /* @__PURE__ */ new Map();
+	#resolutions = /* @__PURE__ */ new Map();
+	#modules = /* @__PURE__ */ new Map();
+	#dependencies = /* @__PURE__ */ new Map();
+	#dependents = /* @__PURE__ */ new Map();
+	#elementCache = /* @__PURE__ */ new Map();
+	#candidate;
+	constructor(factory, project) {
+		for (const input of project.modules) this.#installHostRecord(input);
+		const candidateProject = {
+			files: this.#files,
+			resolutions: this.#resolutions
+		};
+		this.#candidate = factory.create(candidateProject);
+		this.#candidate.link();
+	}
+	moduleIds() {
+		return [...this.#modules.keys()].sort(compareIds);
+	}
+	contentHash(id) {
+		return this.#modules.get(id)?.hash ?? null;
+	}
+	sourceOf(id) {
+		const source = this.#modules.get(id)?.input.source;
+		if (source === void 0) throw new Error(`Unknown host module ${id}`);
+		return source;
+	}
+	dependenciesOf(id) {
+		return [...this.#dependencies.get(id) ?? []].sort(compareIds);
+	}
+	dependentsOf(id) {
+		return [...this.#dependents.get(id) ?? []].sort(compareIds);
+	}
+	/** resolved ids a module imports that the graph does not own (package entries) */
+	externalImportsOf(id) {
+		const record = this.#modules.get(id);
+		if (!record) return [];
+		const ids = /* @__PURE__ */ new Set();
+		for (const dependency of record.input.imports) {
+			if (dependency.external) ids.add(dependency.resolvedId);
+		}
+		return [...ids].sort(compareIds);
+	}
+	affectedBy(id) {
+		const affected = /* @__PURE__ */ new Set([id]);
+		const queue = [id];
+		while (queue.length) {
+			const current = queue.shift();
+			for (const dependent of this.#dependents.get(current) ?? []) {
+				if (affected.has(dependent)) continue;
+				affected.add(dependent);
+				queue.push(dependent);
+			}
+		}
+		return [...affected].sort(compareIds);
+	}
+	parseCount(id) {
+		return this.#candidate.parseCount(id);
+	}
+	resolveBinding(id, localName) {
+		const definition = this.#candidate.definitionOf(id, localName);
+		if (!definition) return null;
+		return {
+			id: definition.id,
+			name: definition.name,
+			span: {
+				id: definition.id,
+				start: definition.start,
+				end: definition.end
+			},
+			initializer: definition.initializer ? (0, import_contracts.expressionReference)(definition.id, definition.initializer) : null,
+			constant: definition.constant
+		};
+	}
+	resolveReference(reference) {
+		const definition = this.#candidate.definitionAt(reference.id, reference.start, reference.end);
+		if (!definition) return null;
+		return {
+			id: definition.id,
+			name: definition.name,
+			span: {
+				id: definition.id,
+				start: definition.start,
+				end: definition.end
+			},
+			initializer: definition.initializer ? (0, import_contracts.expressionReference)(definition.id, definition.initializer) : null,
+			constant: definition.constant
+		};
+	}
+	expressionNode(reference) {
+		if (!this.#modules.has(reference.id)) return null;
+		return (0, import_normalize.nodeAtSpan)(this.#candidate.programOf(reference.id), reference.start, reference.end);
+	}
+	/**
+	* The members of a plain object literal, each as its own expression:
+	* `{ width: expr, height: 10 }`. Null for anything else, and for an object
+	* that spreads, computes a key, or defines a method or accessor.
+	*/
+	objectMembers(reference) {
+		const node = this.expressionNode(reference);
+		if (!node) return null;
+		const object = (0, import_ast.unwrapExpression)(node);
+		if (object.type !== "ObjectExpression") return null;
+		const members = [];
+		for (const property of (0, import_ast.childNodes)(object, "properties")) {
+			if (property.type !== "Property" && property.type !== "ObjectProperty" || property.computed === true || property.method === true || property.kind !== void 0 && property.kind !== "init") {
+				return null;
+			}
+			const key = (0, import_ast.childNode)(property, "key");
+			const value = (0, import_ast.childNode)(property, "value");
+			if (!key || !value) return null;
+			const name = (0, import_ast.identifierName)(key) ?? (typeof key.value === "string" ? key.value : null);
+			if (name === null) return null;
+			members.push({
+				name,
+				span: (0, import_contracts.spanOf)(reference.id, property),
+				value: (0, import_contracts.expressionReference)(reference.id, value)
+			});
+		}
+		return members;
+	}
+	evaluate(reference) {
+		return (0, import_evaluate.evaluateExpression)(this, reference);
+	}
+	evaluateBranches(reference) {
+		return (0, import_evaluate.evaluateBranches)(this, reference);
+	}
+	evaluateDynamic(reference) {
+		return (0, import_evaluate.evaluateDynamicExpression)(this, reference);
+	}
+	evaluateBinding(id, localName) {
+		return (0, import_evaluate.evaluateBinding)(this, id, localName);
+	}
+	elementsOf(id) {
+		const record = this.#modules.get(id);
+		if (!record) throw new Error(`Unknown host module ${id}`);
+		const cached = this.#elementCache.get(id);
+		if (cached?.hash === record.hash) return cached.result;
+		const result = (0, import_normalize.normalizeElements)(this.#candidate, id, record.input.imports);
+		this.#elementCache.set(id, {
+			hash: record.hash,
+			result
+		});
+		return result;
+	}
+	diagnostics() {
+		const diagnostics = this.#candidate.diagnostics().map((diagnostic) => diagnostic.kind === "parse" ? (0, import_diagnostics.localBailout)("local/parse-error", {
+			id: diagnostic.id,
+			start: 0,
+			end: 0
+		}, diagnostic.message) : (0, import_diagnostics.linkedBailout)("linked/unresolved-binding", {
+			id: diagnostic.id,
+			start: 0,
+			end: 0
+		}, diagnostic.message));
+		for (const [id, record] of this.#modules) {
+			for (const dependency of record.input.imports) {
+				if (dependency.external) continue;
+				if (this.#modules.has(dependency.resolvedId)) continue;
+				diagnostics.push((0, import_diagnostics.linkedBailout)("linked/unresolved-import", {
+					id,
+					start: 0,
+					end: 0
+				}, `Host-resolved import ${dependency.specifier} points outside the project graph`, dependency.resolvedId));
+			}
+		}
+		return diagnostics.sort((left, right) => {
+			const byId = compareCodeUnits(left.span.id, right.span.id);
+			return byId || left.span.start - right.span.start || compareCodeUnits(left.code, right.code);
+		});
+	}
+	updateModule(input) {
+		const previous = this.#modules.get(input.id);
+		const nextHash = moduleContentHash(input);
+		if (previous?.hash === nextHash) {
+			return {
+				changed: false,
+				id: input.id,
+				previousHash: previous.hash,
+				contentHash: previous.hash,
+				invalidatedIds: []
+			};
+		}
+		const invalidatedIds = this.affectedBy(input.id);
+		const previousHash = previous?.hash ?? null;
+		if (previous) this.#candidate.removeFile(input.id);
+		this.#installHostRecord(input);
+		this.#candidate.addFile(input.id, input.source);
+		this.#candidate.link();
+		for (const id of invalidatedIds) this.#elementCache.delete(id);
+		return {
+			changed: true,
+			id: input.id,
+			previousHash,
+			contentHash: nextHash,
+			invalidatedIds
+		};
+	}
+	removeModule(id) {
+		const previous = this.#modules.get(id);
+		if (!previous) {
+			return {
+				changed: false,
+				id,
+				previousHash: null,
+				contentHash: null,
+				invalidatedIds: []
+			};
+		}
+		const invalidatedIds = this.affectedBy(id);
+		this.#candidate.removeFile(id);
+		this.#removeOutgoingEdges(id);
+		this.#removeResolutions(id);
+		this.#modules.delete(id);
+		this.#files.delete(id);
+		this.#candidate.link();
+		for (const invalidated of invalidatedIds) this.#elementCache.delete(invalidated);
+		return {
+			changed: true,
+			id,
+			previousHash: previous.hash,
+			contentHash: null,
+			invalidatedIds
+		};
+	}
+	#installHostRecord(input) {
+		(0, import_contracts.resolvedModuleId)(input.id);
+		const seenSpecifiers = /* @__PURE__ */ new Set();
+		for (const dependency of input.imports) {
+			(0, import_contracts.resolvedModuleId)(dependency.resolvedId);
+			if (seenSpecifiers.has(dependency.specifier)) {
+				throw new Error(`Duplicate host resolution for ${input.id}:${dependency.specifier}`);
+			}
+			seenSpecifiers.add(dependency.specifier);
+		}
+		this.#removeOutgoingEdges(input.id);
+		this.#removeResolutions(input.id);
+		const dependencies = new Set(input.imports.filter(({ external }) => !external).map(({ resolvedId }) => resolvedId));
+		this.#dependencies.set(input.id, dependencies);
+		for (const dependency of dependencies) {
+			let reverse = this.#dependents.get(dependency);
+			if (!reverse) {
+				reverse = /* @__PURE__ */ new Set();
+				this.#dependents.set(dependency, reverse);
+			}
+			reverse.add(input.id);
+		}
+		for (const dependency of input.imports) {
+			if (dependency.external) continue;
+			this.#resolutions.set((0, import_contracts.resolutionKey)(input.id, dependency.specifier), dependency.resolvedId);
+		}
+		const installedInput = {
+			...input,
+			imports: input.imports.map((dependency) => ({ ...dependency }))
+		};
+		this.#files.set(installedInput.id, installedInput.source);
+		this.#modules.set(installedInput.id, {
+			input: installedInput,
+			hash: moduleContentHash(installedInput)
+		});
+	}
+	#removeOutgoingEdges(id) {
+		for (const dependency of this.#dependencies.get(id) ?? []) {
+			const reverse = this.#dependents.get(dependency);
+			reverse?.delete(id);
+			if (reverse?.size === 0) this.#dependents.delete(dependency);
+		}
+		this.#dependencies.delete(id);
+	}
+	#removeResolutions(id) {
+		const prefix = `${id}\0`;
+		for (const key of this.#resolutions.keys()) {
+			if (key.startsWith(prefix)) this.#resolutions.delete(key);
+		}
+	}
+};

package/dist/cjs/hash.cjs

@@ -0,0 +1,48 @@
+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 hash_exports = {};
+__export(hash_exports, {
+	contentHash: () => contentHash,
+	stableStringify: () => stableStringify
+});
+module.exports = __toCommonJS(hash_exports);
+var import_node_crypto = require("node:crypto");
+function contentHash(value) {
+	return (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+}
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function stringify(value) {
+	if (Array.isArray(value)) {
+		return `[${value.map((child) => stringify(child) ?? "null").join(",")}]`;
+	}
+	if (value && typeof value === "object") {
+		const entries = Object.entries(value).sort(([left], [right]) => compareCodeUnits(left, right)).map(([key, child]) => [key, stringify(child)]).filter((entry) => entry[1] !== void 0);
+		return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${child}`).join(",")}}`;
+	}
+	return JSON.stringify(value);
+}
+function stableStringify(value) {
+	const serialized = stringify(value);
+	if (serialized === void 0) throw new Error("Cannot serialize undefined cache root");
+	return serialized;
+}

package/dist/cjs/index.cjs

@@ -0,0 +1,43 @@
+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 index_exports = {};
+__export(index_exports, {
+	normalizeElements: () => import_normalize.normalizeElements,
+	parseModuleAst: () => import_yuku.parseModuleAst,
+	yukuFactory: () => import_yuku.yukuFactory
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./ast.cjs"), module.exports);
+__reExport(index_exports, require("./contracts.cjs"), module.exports);
+__reExport(index_exports, require("./diagnostics.cjs"), module.exports);
+__reExport(index_exports, require("./evaluate.cjs"), module.exports);
+__reExport(index_exports, require("./graph.cjs"), module.exports);
+__reExport(index_exports, require("./hash.cjs"), module.exports);
+__reExport(index_exports, require("./ir.cjs"), module.exports);
+__reExport(index_exports, require("./lower.cjs"), module.exports);
+__reExport(index_exports, require("./materialize.cjs"), module.exports);
+__reExport(index_exports, require("./output.cjs"), module.exports);
+__reExport(index_exports, require("./planCache.cjs"), module.exports);
+__reExport(index_exports, require("./session.cjs"), module.exports);
+var import_normalize = require("./normalize.cjs");
+__reExport(index_exports, require("./zero.cjs"), module.exports);
+var import_yuku = require("./yuku.cjs");

package/dist/cjs/ir.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 ir_exports = {};
+__export(ir_exports, { hostImportProvenance: () => hostImportProvenance });
+module.exports = __toCommonJS(ir_exports);
+function hostImportProvenance(imports, specifier, importedName) {
+	const resolution = imports.find((candidate) => candidate.specifier === specifier);
+	return resolution ? {
+		specifier,
+		importedName,
+		resolvedId: resolution.resolvedId,
+		external: resolution.external === true
+	} : null;
+}

package/dist/cjs/lower.cjs

@@ -0,0 +1,232 @@
+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 lower_exports = {};
+__export(lower_exports, {
+	LOWERED_MODULE_PLAN_VERSION: () => LOWERED_MODULE_PLAN_VERSION,
+	lowerModule: () => lowerModule
+});
+module.exports = __toCommonJS(lower_exports);
+var import_diagnostics = require("./diagnostics.cjs");
+var import_output = require("./output.cjs");
+const LOWERED_MODULE_PLAN_VERSION = 3;
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function blocking(reason) {
+	return {
+		...reason,
+		blocking: true
+	};
+}
+function diagnostic(code, element, message, prop) {
+	return {
+		...(0, import_diagnostics.localBailout)(code, element.span, message),
+		component: element.component.name,
+		specifier: element.component.provenance?.specifier,
+		prop
+	};
+}
+function styledDefinitionFor(module2, element) {
+	const definition = element.component.definition;
+	if (!definition) return null;
+	return module2.styledDefinitions.find((candidate) => candidate.id === definition.id && candidate.name === definition.name) ?? null;
+}
+function unsafeEntry(element, entry, component, host) {
+	if (entry.kind === "spread" && entry.value.kind !== "static") {
+		return diagnostic("local/unsafe-style-spread", element, "Unevaluated spread may change style and duplicate-prop precedence");
+	}
+	if (entry.kind === "prop" && host.isStyleProp(entry.name, component) && (entry.value.kind === "bailout" || entry.value.kind === "conditional") && !host.canLowerDynamicStyleProp?.(entry.name, component, entry.value.kind)) {
+		return diagnostic("local/dynamic-style-value", element, `Style prop ${entry.name} could not be evaluated`, entry.name);
+	}
+	if (entry.kind === "prop" && entry.value.kind === "object") {
+		for (const member of entry.value.members) {
+			if (member.value.kind !== "bailout" && member.value.kind !== "conditional") continue;
+			if (!host.isStyleProp(member.name, component) || !host.canLowerDynamicStyleProp?.(member.name, component, member.value.kind)) {
+				return diagnostic("local/dynamic-style-value", element, `Style prop ${member.name} could not be evaluated`, member.name);
+			}
+		}
+	}
+	return null;
+}
+function editsAreCandidateLocal(element, edits) {
+	return edits.every((edit) => edit.origin.id === element.id && edit.start >= element.span.start && edit.end <= element.span.end);
+}
+function overlapsCommitted(edits, committed) {
+	return edits.some((edit) => committed.some((existing) => {
+		if (edit.start === edit.end) {
+			return edit.start > existing.start && edit.start < existing.end;
+		}
+		if (existing.start === existing.end) {
+			return existing.start > edit.start && existing.start < edit.end;
+		}
+		return edit.start < existing.end && existing.start < edit.end;
+	}));
+}
+function lowerModule({ module: module2, source, target, host, options, structuralPass }) {
+	const stats = {
+		found: 0,
+		lowered: 0,
+		flattened: 0,
+		styled: 0,
+		bailed: 0
+	};
+	const structural = structuralPass ? structuralPass.transform({
+		module: module2,
+		source,
+		target
+	}) : {
+		module: module2,
+		edits: [],
+		imports: [],
+		diagnostics: [],
+		dependencies: []
+	};
+	if (structural.module.id !== module2.id) {
+		throw new Error(`Structural pass changed module identity from ${module2.id} to ${structural.module.id}`);
+	}
+	if (structuralPass && !structuralPass.versionHash) {
+		throw new Error("Structural pass must provide a non-empty version hash");
+	}
+	module2 = structural.module;
+	(0, import_output.validateSourceEdits)(source, structural.edits);
+	const edits = [...structural.edits];
+	const css = /* @__PURE__ */ new Set();
+	const diagnostics = [...module2.diagnostics, ...structural.diagnostics];
+	const dependencies = /* @__PURE__ */ new Set([...module2.dependencies, ...structural.dependencies]);
+	const imports = new Map(structural.imports.map((candidateImport) => [candidateImport.content, candidateImport]));
+	for (const element of module2.elements) {
+		const styledDefinition = styledDefinitionFor(module2, element);
+		const component = host.resolveComponent(element, styledDefinition);
+		if (!component) continue;
+		stats.found++;
+		const input = {
+			id: module2.id,
+			source,
+			target,
+			module: module2,
+			element,
+			styledDefinition,
+			component
+		};
+		const commitDevelopmentDebug = (result2) => {
+			const debugEdits = host.developmentDebugInstrumentation?.(input, result2);
+			if (!debugEdits) return;
+			(0, import_output.validateSourceEdits)(source, debugEdits);
+			if (!editsAreCandidateLocal(element, debugEdits) || overlapsCommitted(debugEdits, edits)) {
+				throw new Error("Development debug instrumentation must stay candidate-local");
+			}
+			edits.push(...debugEdits);
+		};
+		if (!element.complete || styledDefinition && !styledDefinition.complete) {
+			const reasons = [...element.bailouts.map(blocking), ...(styledDefinition?.bailouts ?? []).map(blocking)];
+			diagnostics.push(...reasons);
+			const reason = reasons[0];
+			if (reason) commitDevelopmentDebug({
+				ok: false,
+				bailout: reason
+			});
+			stats.bailed++;
+			continue;
+		}
+		const unsafe = element.entries.map((entry) => unsafeEntry(element, entry, component, host)).find((result2) => result2 !== null);
+		if (unsafe) {
+			diagnostics.push(blocking(unsafe));
+			commitDevelopmentDebug({
+				ok: false,
+				bailout: blocking(unsafe)
+			});
+			stats.bailed++;
+			continue;
+		}
+		let result;
+		try {
+			result = host.lowerCandidate(input);
+		} catch (error) {
+			result = {
+				ok: false,
+				bailout: diagnostic("local/style-resolution-failed", element, `Style resolution failed: ${error instanceof Error ? error.message : String(error)}`)
+			};
+		}
+		if (!result.ok) {
+			diagnostics.push(blocking(result.bailout));
+			commitDevelopmentDebug(result);
+			stats.bailed++;
+			continue;
+		}
+		try {
+			(0, import_output.validateSourceEdits)(source, result.edits);
+		} catch (error) {
+			const reason = blocking(diagnostic("local/overlapping-edit", element, error instanceof Error ? error.message : String(error)));
+			diagnostics.push(reason);
+			commitDevelopmentDebug({
+				ok: false,
+				bailout: reason
+			});
+			stats.bailed++;
+			continue;
+		}
+		if (!editsAreCandidateLocal(element, result.edits) || overlapsCommitted(result.edits, edits)) {
+			const reason = blocking(diagnostic("local/overlapping-edit", element, "Candidate edits overlap another candidate or escape the element span"));
+			diagnostics.push(reason);
+			commitDevelopmentDebug({
+				ok: false,
+				bailout: reason
+			});
+			stats.bailed++;
+			continue;
+		}
+		diagnostics.push(...result.diagnostics ?? []);
+		edits.push(...result.edits);
+		commitDevelopmentDebug(result);
+		for (const rule of result.css) css.add(rule);
+		for (const candidateImport of result.imports) {
+			if (!imports.has(candidateImport.content)) {
+				imports.set(candidateImport.content, candidateImport);
+			}
+		}
+		for (const dependency of result.dependencies ?? []) dependencies.add(dependency);
+		stats.lowered++;
+		if (result.flattened) stats.flattened++;
+		if (styledDefinition) stats.styled++;
+	}
+	for (const candidateImport of imports.values()) {
+		edits.push({
+			start: source.length,
+			end: source.length,
+			content: candidateImport.content,
+			origin: candidateImport.origin
+		});
+	}
+	return {
+		version: LOWERED_MODULE_PLAN_VERSION,
+		id: module2.id,
+		target,
+		inputHash: module2.inputHash,
+		sourceHash: (0, import_output.sourceContentHash)(source),
+		projectGeneration: options.projectGeneration,
+		structuralPassHash: structuralPass?.versionHash ?? `${target}-noop-v1`,
+		edits,
+		css: [...css].join(""),
+		diagnostics,
+		dependencies: [...dependencies].sort(compareCodeUnits),
+		stats
+	};
+}