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

package/dist/cjs/normalize.cjs

@@ -0,0 +1,622 @@
+
+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 normalize_exports = {};
+__export(normalize_exports, {
+	asAstNode: () => asAstNode,
+	declarationForName: () => declarationForName,
+	definitionFromDeclaration: () => definitionFromDeclaration,
+	nodeAtSpan: () => nodeAtSpan,
+	normalizeElements: () => normalizeElements
+});
+module.exports = __toCommonJS(normalize_exports);
+var import_ast = require("./ast.cjs");
+var import_contracts = require("./contracts.cjs");
+var import_diagnostics = require("./diagnostics.cjs");
+var import_ir = require("./ir.cjs");
+function finalizeElement(base, entries, bailouts) {
+	if (bailouts.length === 0) {
+		return {
+			...base,
+			complete: true,
+			entries,
+			bailouts: []
+		};
+	}
+	return {
+		...base,
+		complete: false,
+		bailedEntries: entries,
+		bailouts
+	};
+}
+function definitionFromDeclaration(id, name, program, declaration) {
+	let identifier = declaration;
+	let initializer = null;
+	let constant = false;
+	if (declaration.type === "VariableDeclarator") {
+		identifier = (0, import_ast.childNode)(declaration, "id") ?? declaration;
+		initializer = (0, import_ast.childNode)(declaration, "init");
+		constant = !!(0, import_ast.findAstNode)(program, (node) => node.type === "VariableDeclaration" && node.kind === "const" && (0, import_ast.childNodes)(node, "declarations").some((candidate) => candidate.start === declaration.start));
+	} else if (declaration.type === "Identifier") {
+		const declarator = (0, import_ast.findAstNode)(program, (node) => node.type === "VariableDeclarator" && (0, import_ast.childNode)(node, "id")?.start === declaration.start);
+		if (declarator) {
+			initializer = (0, import_ast.childNode)(declarator, "init");
+			constant = !!(0, import_ast.findAstNode)(program, (node) => node.type === "VariableDeclaration" && node.kind === "const" && (0, import_ast.childNodes)(node, "declarations").some((candidate) => candidate.start === declarator.start));
+		}
+	}
+	return {
+		id: (0, import_contracts.resolvedModuleId)(id),
+		name,
+		start: identifier.start,
+		end: identifier.end,
+		initializer,
+		constant
+	};
+}
+function importBinding(program, localName) {
+	for (const statement of (0, import_ast.childNodes)(program, "body")) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const source = (0, import_ast.childNode)(statement, "source");
+		const sourceValue = source && typeof source.value === "string" ? source.value : null;
+		if (!sourceValue) continue;
+		for (const specifier of (0, import_ast.childNodes)(statement, "specifiers")) {
+			if ((0, import_ast.identifierName)((0, import_ast.childNode)(specifier, "local")) !== localName) continue;
+			if (specifier.type === "ImportDefaultSpecifier") {
+				return {
+					source: sourceValue,
+					imported: "default"
+				};
+			}
+			if (specifier.type === "ImportNamespaceSpecifier") {
+				return {
+					source: sourceValue,
+					imported: "*"
+				};
+			}
+			const imported = (0, import_ast.childNode)(specifier, "imported");
+			const importedName = (0, import_ast.identifierName)(imported) ?? (typeof imported?.value === "string" ? imported.value : null);
+			return importedName ? {
+				source: sourceValue,
+				imported: importedName
+			} : null;
+		}
+	}
+	return null;
+}
+function asStaticValue(node) {
+	if (!node) return void 0;
+	if (node.type === "NullLiteral") return null;
+	if (node.type === "Literal" || node.type.endsWith("Literal")) {
+		const value = node.value;
+		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+			return value;
+		}
+	}
+	return void 0;
+}
+function elementValue(id, node) {
+	const staticValue = asStaticValue(node);
+	return staticValue === void 0 ? (0, import_contracts.expressionReference)(id, node) : {
+		kind: "static",
+		value: staticValue,
+		span: (0, import_contracts.spanOf)(id, node)
+	};
+}
+function symbolDefinition(definition) {
+	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
+	};
+}
+function componentFromNode(candidate, id, program, imports, node, bailouts) {
+	const literal = asStaticValue(node);
+	if (typeof literal === "string") {
+		return {
+			kind: "intrinsic",
+			name: literal,
+			span: (0, import_contracts.spanOf)(id, node),
+			closingSpan: null,
+			definition: null,
+			provenance: null
+		};
+	}
+	if ((node.type === "MemberExpression" || node.type === "JSXMemberExpression") && node.computed !== true) {
+		const objectName = (0, import_ast.identifierName)((0, import_ast.childNode)(node, "object"));
+		const memberName = (0, import_ast.identifierName)((0, import_ast.childNode)(node, "property"));
+		const binding2 = objectName ? importBinding(program, objectName) : null;
+		if (memberName && binding2?.imported === "html") {
+			const provenance2 = (0, import_ir.hostImportProvenance)(imports, binding2.source, binding2.imported);
+			if (provenance2) {
+				return {
+					kind: "binding",
+					name: memberName,
+					span: (0, import_contracts.spanOf)(id, node),
+					closingSpan: null,
+					definition: null,
+					provenance: provenance2
+				};
+			}
+		}
+	}
+	const name = (0, import_ast.identifierName)(node);
+	if (!name) {
+		bailouts.push((0, import_diagnostics.localBailout)("local/unsupported-element-name", (0, import_contracts.spanOf)(id, node), `Element target ${node.type} is not a stable identifier or intrinsic tag`));
+		return null;
+	}
+	const intrinsic = /^[a-z]/.test(name);
+	const binding = intrinsic ? null : importBinding(program, name);
+	const provenance = binding ? (0, import_ir.hostImportProvenance)(imports, binding.source, binding.imported) : null;
+	const definition = intrinsic ? null : symbolDefinition(candidate.definitionOf(id, name));
+	if (!intrinsic && !definition && !provenance) {
+		bailouts.push((0, import_diagnostics.linkedBailout)("linked/unresolved-component-binding", (0, import_contracts.spanOf)(id, node), `Component binding ${name} has no linked definition`));
+	}
+	return {
+		kind: intrinsic ? "intrinsic" : "binding",
+		name,
+		span: (0, import_contracts.spanOf)(id, node),
+		closingSpan: null,
+		definition,
+		provenance
+	};
+}
+function jsxComponentNode(opening) {
+	return (0, import_ast.childNode)(opening, "name");
+}
+function jsxEntries(id, element, opening, bailouts) {
+	const entries = [];
+	for (const attribute of (0, import_ast.childNodes)(opening, "attributes")) {
+		if (attribute.type === "JSXSpreadAttribute") {
+			const argument = (0, import_ast.childNode)(attribute, "argument");
+			if (argument) {
+				entries.push({
+					kind: "spread",
+					span: (0, import_contracts.spanOf)(id, attribute),
+					value: (0, import_contracts.expressionReference)(id, argument)
+				});
+			}
+			continue;
+		}
+		if (attribute.type !== "JSXAttribute") continue;
+		const nameNode = (0, import_ast.childNode)(attribute, "name");
+		const name = (0, import_ast.identifierName)(nameNode);
+		if (!name) {
+			bailouts.push((0, import_diagnostics.localBailout)("local/unsupported-prop-key", (0, import_contracts.spanOf)(id, attribute), "Namespaced JSX attributes are not statically supported"));
+			continue;
+		}
+		const rawValue = (0, import_ast.childNode)(attribute, "value");
+		let value;
+		if (!rawValue) {
+			value = {
+				kind: "static",
+				value: true,
+				span: (0, import_contracts.spanOf)(id, attribute)
+			};
+		} else if (rawValue.type === "JSXExpressionContainer") {
+			const expression = (0, import_ast.childNode)(rawValue, "expression");
+			if (!expression || expression.type === "JSXEmptyExpression") {
+				bailouts.push((0, import_diagnostics.localBailout)("local/unsupported-expression", (0, import_contracts.spanOf)(id, rawValue), `JSX prop ${name} has no expression`));
+				continue;
+			}
+			value = elementValue(id, expression);
+		} else {
+			value = elementValue(id, rawValue);
+		}
+		entries.push({
+			kind: "prop",
+			name,
+			span: (0, import_contracts.spanOf)(id, attribute),
+			value
+		});
+	}
+	for (const child of (0, import_ast.childNodes)(element, "children")) {
+		let value;
+		if (child.type === "JSXText") {
+			if (typeof child.value !== "string" || child.value.trim() === "") continue;
+			value = {
+				kind: "static",
+				value: child.value,
+				span: (0, import_contracts.spanOf)(id, child)
+			};
+		} else if (child.type === "JSXExpressionContainer") {
+			const expression = (0, import_ast.childNode)(child, "expression");
+			value = !expression || expression.type === "JSXEmptyExpression" ? {
+				kind: "empty",
+				span: (0, import_contracts.spanOf)(id, child)
+			} : elementValue(id, expression);
+		} else if (child.type === "JSXElement" || child.type === "JSXFragment") {
+			value = {
+				kind: "element",
+				span: (0, import_contracts.spanOf)(id, child)
+			};
+		} else {
+			bailouts.push((0, import_diagnostics.localBailout)("local/unsupported-child", (0, import_contracts.spanOf)(id, child), `JSX child ${child.type} cannot be normalized`));
+			continue;
+		}
+		entries.push({
+			kind: "child",
+			span: (0, import_contracts.spanOf)(id, child),
+			value
+		});
+	}
+	return entries.sort((left, right) => left.span.start - right.span.start);
+}
+function propertyName(property) {
+	if (property.computed === true) return null;
+	const key = (0, import_ast.childNode)(property, "key");
+	const name = (0, import_ast.identifierName)(key);
+	if (name) return name;
+	const literal = asStaticValue(key);
+	return typeof literal === "string" || typeof literal === "number" ? String(literal) : null;
+}
+function runtimeChildEntries(id, program, node, bailouts) {
+	const rawNodes = node.type === "ArrayExpression" ? node.elements : null;
+	if (Array.isArray(rawNodes) && rawNodes.some((child) => child === null || !(0, import_ast.isAstNode)(child))) {
+		bailouts.push((0, import_diagnostics.localBailout)("local/unsupported-child", (0, import_contracts.spanOf)(id, node), "Sparse compiled children cannot be normalized without changing order"));
+		return [];
+	}
+	const nodes = Array.isArray(rawNodes) ? rawNodes.filter(import_ast.isAstNode) : [node];
+	return nodes.flatMap((child) => {
+		if (child.type === "SpreadElement") {
+			bailouts.push((0, import_diagnostics.localBailout)("local/unsupported-child", (0, import_contracts.spanOf)(id, child), "Spread children cannot be statically ordered"));
+			return [];
+		}
+		if (child.type === "CallExpression" && runtimeCall(program, child)) {
+			return [{
+				kind: "child",
+				span: (0, import_contracts.spanOf)(id, child),
+				value: {
+					kind: "element",
+					span: (0, import_contracts.spanOf)(id, child)
+				}
+			}];
+		}
+		return [{
+			kind: "child",
+			span: (0, import_contracts.spanOf)(id, child),
+			value: elementValue(id, child)
+		}];
+	});
+}
+function objectEntries(id, program, object, bailouts) {
+	const entries = [];
+	for (const property of (0, import_ast.childNodes)(object, "properties")) {
+		if (property.type === "SpreadElement") {
+			const argument = (0, import_ast.childNode)(property, "argument");
+			if (argument) {
+				const spread = {
+					kind: "spread",
+					span: (0, import_contracts.spanOf)(id, property),
+					value: (0, import_contracts.expressionReference)(id, argument)
+				};
+				entries.push(spread);
+			}
+			continue;
+		}
+		if (property.type !== "Property" && property.type !== "ObjectProperty") {
+			bailouts.push((0, import_diagnostics.localBailout)("local/unsupported-prop-key", (0, import_contracts.spanOf)(id, property), `Runtime props entry ${property.type} is not a data property`));
+			continue;
+		}
+		const name = propertyName(property);
+		const valueNode = (0, import_ast.childNode)(property, "value");
+		if (!name || !valueNode) {
+			bailouts.push((0, import_diagnostics.localBailout)("local/unsupported-prop-key", (0, import_contracts.spanOf)(id, property), "Computed runtime prop keys are not statically supported"));
+			continue;
+		}
+		if (name === "children") {
+			entries.push(...runtimeChildEntries(id, program, valueNode, bailouts));
+			continue;
+		}
+		const prop = {
+			kind: "prop",
+			name,
+			span: (0, import_contracts.spanOf)(id, property),
+			value: elementValue(id, valueNode)
+		};
+		entries.push(prop);
+	}
+	return entries;
+}
+function runtimeCall(program, call) {
+	const callee = (0, import_ast.childNode)(call, "callee");
+	if (!callee) return null;
+	const directName = (0, import_ast.identifierName)(callee);
+	if (directName) {
+		const provenance2 = importBinding(program, directName);
+		if (provenance2?.source === "react/jsx-runtime" && (provenance2.imported === "jsx" || provenance2.imported === "jsxs")) {
+			return { form: "jsx-runtime" };
+		}
+		if (provenance2?.source === "react" && provenance2.imported === "createElement") {
+			return { form: "create-element" };
+		}
+	}
+	if (callee.type !== "MemberExpression" || callee.computed === true) return null;
+	const objectName = (0, import_ast.identifierName)((0, import_ast.childNode)(callee, "object"));
+	const propertyName2 = (0, import_ast.identifierName)((0, import_ast.childNode)(callee, "property"));
+	if (propertyName2 !== "createElement" || !objectName) return null;
+	const provenance = importBinding(program, objectName);
+	return provenance?.source === "react" && (provenance.imported === "default" || provenance.imported === "*") ? { form: "create-element" } : null;
+}
+function normalizeRuntimeElement(candidate, id, program, imports, call, runtime, bailouts) {
+	const bailoutStart = bailouts.length;
+	const args = (0, import_ast.childNodes)(call, "arguments");
+	const target = args[0];
+	if (!target) {
+		bailouts.push((0, import_diagnostics.localBailout)("local/invalid-element-call", (0, import_contracts.spanOf)(id, call), `${runtime.form} call has no element target`));
+		return null;
+	}
+	const component = componentFromNode(candidate, id, program, imports, target, bailouts);
+	if (!component) return null;
+	const entries = [];
+	const props = args[1];
+	if (props && asStaticValue(props) !== null) {
+		if (props.type === "ObjectExpression") {
+			entries.push(...objectEntries(id, program, props, bailouts));
+		} else {
+			entries.push({
+				kind: "spread",
+				span: (0, import_contracts.spanOf)(id, props),
+				value: (0, import_contracts.expressionReference)(id, props)
+			});
+		}
+	}
+	if (runtime.form === "create-element") {
+		for (const child of args.slice(2)) {
+			entries.push(...runtimeChildEntries(id, program, child, bailouts));
+		}
+	}
+	return finalizeElement({
+		kind: "element",
+		form: runtime.form,
+		id,
+		span: (0, import_contracts.spanOf)(id, call),
+		propsSpan: props ? (0, import_contracts.spanOf)(id, props) : null,
+		component
+	}, entries.sort((left, right) => left.span.start - right.span.start), bailouts.slice(bailoutStart));
+}
+function styledDefinitions(candidate, id, program, imports, bailouts) {
+	const definitions = [];
+	(0, import_ast.walkAst)(program, (node) => {
+		if (node.type !== "VariableDeclarator") return;
+		const identifier = (0, import_ast.childNode)(node, "id");
+		const name = (0, import_ast.identifierName)(identifier);
+		const call = (0, import_ast.childNode)(node, "init");
+		if (!name || !identifier || call?.type !== "CallExpression") return;
+		const callee = (0, import_ast.childNode)(call, "callee");
+		const factoryName = callee && (0, import_ast.identifierName)(callee);
+		if (!factoryName) return;
+		const binding = importBinding(program, factoryName);
+		if (!binding || binding.imported !== "styled") return;
+		const factory = (0, import_ir.hostImportProvenance)(imports, binding.source, binding.imported);
+		if (!factory) return;
+		const definitionBailouts = [];
+		const args = (0, import_ast.childNodes)(call, "arguments");
+		const baseNode = args[0];
+		const optionsNode = args.length >= 3 ? args[2] : args[1];
+		if (!baseNode || !optionsNode) {
+			definitionBailouts.push((0, import_diagnostics.localBailout)("local/unsupported-styled-definition", (0, import_contracts.spanOf)(id, call), `styled definition ${name} must provide a base and options object`));
+			bailouts.push(...definitionBailouts);
+			return;
+		}
+		const base = componentFromNode(candidate, id, program, imports, baseNode, definitionBailouts);
+		if (!base) {
+			bailouts.push(...definitionBailouts);
+			return;
+		}
+		const baseClassNode = args.length >= 3 ? args[1] : null;
+		const baseDefinition = {
+			kind: "styled-definition",
+			id,
+			name,
+			span: (0, import_contracts.spanOf)(id, call),
+			definitionSpan: (0, import_contracts.spanOf)(id, identifier),
+			factory,
+			base,
+			baseClassName: baseClassNode ? elementValue(id, baseClassNode) : null,
+			options: (0, import_contracts.expressionReference)(id, optionsNode)
+		};
+		definitions.push(definitionBailouts.length === 0 ? {
+			...baseDefinition,
+			complete: true,
+			bailouts: []
+		} : {
+			...baseDefinition,
+			complete: false,
+			bailouts: definitionBailouts
+		});
+		bailouts.push(...definitionBailouts);
+	});
+	return definitions.sort((left, right) => left.span.start - right.span.start);
+}
+const DOM_STYLE_FRONTENDS = /* @__PURE__ */ new Set([
+	"tamagui/dom",
+	"@tamagui/core/dom",
+	"@tamagui/tailwind"
+]);
+function domStyleDefinitions(id, program, imports) {
+	const definitions = [];
+	(0, import_ast.walkAst)(program, (node) => {
+		if (node.type !== "VariableDeclarator") return;
+		const identifier = (0, import_ast.childNode)(node, "id");
+		const name = (0, import_ast.identifierName)(identifier);
+		const call = (0, import_ast.childNode)(node, "init");
+		if (!name || !identifier || call?.type !== "CallExpression") return;
+		const callee = (0, import_ast.childNode)(call, "callee");
+		const factoryName = callee && (0, import_ast.identifierName)(callee);
+		if (!factoryName) return;
+		const binding = importBinding(program, factoryName);
+		if (!binding || binding.imported !== "style" || !DOM_STYLE_FRONTENDS.has(binding.source)) {
+			return;
+		}
+		const factory = (0, import_ir.hostImportProvenance)(imports, binding.source, binding.imported);
+		const value = (0, import_ast.childNodes)(call, "arguments")[0];
+		if (!factory || !value) return;
+		definitions.push({
+			kind: "dom-style-definition",
+			id,
+			name,
+			span: (0, import_contracts.spanOf)(id, call),
+			definitionSpan: (0, import_contracts.spanOf)(id, identifier),
+			factory,
+			value: (0, import_contracts.expressionReference)(id, value)
+		});
+	});
+	return definitions.sort((left, right) => left.span.start - right.span.start);
+}
+function domStyleArgument(candidate, id, program, node) {
+	let call = node;
+	if (node.type === "Identifier") {
+		const name = (0, import_ast.identifierName)(node);
+		const definition = name ? candidate.definitionOf(id, name) : null;
+		if (!definition?.constant || !definition.initializer) return null;
+		call = definition.initializer;
+	}
+	if (call.type !== "CallExpression") return null;
+	const callee = (0, import_ast.childNode)(call, "callee");
+	const factoryName = callee && (0, import_ast.identifierName)(callee);
+	if (!factoryName) return null;
+	const binding = importBinding(program, factoryName);
+	if (!binding || binding.imported !== "style" || !DOM_STYLE_FRONTENDS.has(binding.source)) {
+		return null;
+	}
+	return (0, import_ast.childNodes)(call, "arguments")[0] ?? null;
+}
+function domStyleProgram(candidate, id, program, node) {
+	if (node.type !== "ArrayExpression" || !Array.isArray(node.elements)) {
+		const argument = domStyleArgument(candidate, id, program, node);
+		return argument ? {
+			kind: "dom-style",
+			span: (0, import_contracts.spanOf)(id, node),
+			items: [{
+				condition: null,
+				value: (0, import_contracts.expressionReference)(id, argument)
+			}]
+		} : null;
+	}
+	const items = [];
+	for (const rawItem of node.elements) {
+		if (!(0, import_ast.isAstNode)(rawItem)) return null;
+		let item = rawItem;
+		let condition = null;
+		if (item.type === "LogicalExpression" && item.operator === "&&") {
+			const left = (0, import_ast.childNode)(item, "left");
+			const right = (0, import_ast.childNode)(item, "right");
+			if (!left || !right) return null;
+			condition = (0, import_contracts.expressionReference)(id, left);
+			item = right;
+		}
+		const argument = domStyleArgument(candidate, id, program, item);
+		if (!argument) {
+			const staticValue = asStaticValue(item);
+			if (staticValue === false || staticValue === null) continue;
+			return null;
+		}
+		items.push({
+			condition,
+			value: (0, import_contracts.expressionReference)(id, argument)
+		});
+	}
+	return {
+		kind: "dom-style",
+		span: (0, import_contracts.spanOf)(id, node),
+		items
+	};
+}
+function normalizeElements(candidate, rawId, imports = []) {
+	const id = (0, import_contracts.resolvedModuleId)(rawId);
+	const program = candidate.programOf(id);
+	const elements = [];
+	const bailouts = [];
+	(0, import_ast.walkAst)(program, (node) => {
+		if (node.type === "JSXElement") {
+			const bailoutStart = bailouts.length;
+			const opening = (0, import_ast.childNode)(node, "openingElement");
+			const target = opening && jsxComponentNode(opening);
+			if (!opening || !target) return;
+			const component = componentFromNode(candidate, id, program, imports, target, bailouts);
+			if (!component) return;
+			const closingElement = (0, import_ast.childNode)(node, "closingElement");
+			const closingName = closingElement && (0, import_ast.childNode)(closingElement, "name");
+			if (closingName) component.closingSpan = (0, import_contracts.spanOf)(id, closingName);
+			const entries = jsxEntries(id, node, opening, bailouts);
+			for (const entry of entries) {
+				if (entry.kind !== "prop" || entry.name !== "style") continue;
+				const raw = entry.value.kind === "expression" ? nodeAtSpan(program, entry.value.start, entry.value.end) : null;
+				const styleProgram = raw && domStyleProgram(candidate, id, program, raw);
+				const argument = raw && domStyleArgument(candidate, id, program, raw);
+				if (styleProgram) entry.value = styleProgram;
+				else if (argument) entry.value = (0, import_contracts.expressionReference)(id, argument);
+			}
+			elements.push(finalizeElement({
+				kind: "element",
+				form: "jsx",
+				id,
+				span: (0, import_contracts.spanOf)(id, node),
+				propsSpan: (0, import_contracts.spanOf)(id, opening),
+				component
+			}, entries, bailouts.slice(bailoutStart)));
+			return;
+		}
+		if (node.type !== "CallExpression") return;
+		const runtime = runtimeCall(program, node);
+		if (!runtime) return;
+		const element = normalizeRuntimeElement(candidate, id, program, imports, node, runtime, bailouts);
+		if (element) {
+			const entries = element.complete ? element.entries : element.bailedEntries;
+			for (const entry of entries) {
+				if (entry.kind !== "prop" || entry.name !== "style") continue;
+				const raw = entry.value.kind === "expression" ? nodeAtSpan(program, entry.value.start, entry.value.end) : null;
+				const styleProgram = raw && domStyleProgram(candidate, id, program, raw);
+				const argument = raw && domStyleArgument(candidate, id, program, raw);
+				if (styleProgram) entry.value = styleProgram;
+				else if (argument) entry.value = (0, import_contracts.expressionReference)(id, argument);
+			}
+			elements.push(element);
+		}
+	});
+	return {
+		elements: elements.sort((left, right) => left.span.start - right.span.start),
+		styledDefinitions: styledDefinitions(candidate, id, program, imports, bailouts),
+		domStyleDefinitions: domStyleDefinitions(id, program, imports),
+		bailouts: bailouts.sort((left, right) => left.span.start - right.span.start)
+	};
+}
+function declarationForName(program, name) {
+	return (0, import_ast.findAstNode)(program, (node) => {
+		if (node.type !== "VariableDeclarator") return false;
+		return (0, import_ast.identifierName)((0, import_ast.childNode)(node, "id")) === name;
+	});
+}
+function nodeAtSpan(program, start, end) {
+	return (0, import_ast.findAstNode)(program, (node) => node.start === start && node.end === end);
+}
+function asAstNode(value, label) {
+	if (!(0, import_ast.isAstNode)(value)) throw new Error(`${label} is not an AST node`);
+	return value;
+}