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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Nate Wienert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1 +1,57 @@
-# @tamagui/compiler-core
+# `@tamagui/compiler-core`
+
+`CompilerSession` is Tamagui's bundler-neutral compiler API. It owns parsing,
+the module graph, invalidation, lowering, and source-map-aware output. The host
+owns resolution and loading.
+
+```ts
+import {
+  CompilerSession,
+  resolvedModuleId,
+  type CompilerAdapter,
+  type HostModuleInput,
+} from '@tamagui/compiler-core'
+
+const session = new CompilerSession()
+const entry: HostModuleInput = {
+  id: resolvedModuleId('/app/Button.tsx'),
+  source: buttonSource,
+  imports: [
+    {
+      specifier: './tokens',
+      resolvedId: resolvedModuleId('/app/tokens.ts'),
+    },
+  ],
+}
+
+const adapter: CompilerAdapter = {
+  target: 'web',
+  projectGeneration: configHash,
+  host: createYourLoweringHost(),
+  async load(id) {
+    return modules.get(id) ?? null
+  },
+}
+
+const result = await session.compile({ module: entry, adapter })
+```
+
+Every `HostModuleInput` must contain a canonical id and every import must
+already be resolved by the host. Mark package or runtime boundaries with
+`external: true`. Call `update()` or `remove()` on watch changes and use the
+returned ids to invalidate the host's module graph. Change
+`projectGeneration` whenever Tamagui config or component metadata changes.
+
+Adapters should pass the output source map back to their bundler and watch the
+dependencies they loaded. Native adapters must reject CSS output rather than
+silently dropping it.
+
+The maintained adapters are:
+
+- `@tamagui/vite-plugin` for Vite web and One's iOS/Android Rolldown pipeline
+  through its Vite config provider API
+- `@tamagui/metro-plugin` for Metro's main-process graph and worker cache
+- `tamagui build` for explicit precompilation, including Next.js Turbopack
+
+The legacy `@tamagui/next-plugin` and `tamagui-loader` packages only support
+webpack and are outside the v3 compiler path.

package/dist/cjs/ast.cjs

@@ -0,0 +1,95 @@
+
+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 ast_exports = {};
+__export(ast_exports, {
+	childNode: () => childNode,
+	childNodes: () => childNodes,
+	findAstNode: () => findAstNode,
+	identifierName: () => identifierName,
+	isAstNode: () => isAstNode,
+	literalValue: () => literalValue,
+	unwrapExpression: () => unwrapExpression,
+	walkAst: () => walkAst
+});
+module.exports = __toCommonJS(ast_exports);
+const ignoredKeys = /* @__PURE__ */ new Set([
+	"loc",
+	"range",
+	"parent",
+	"comments",
+	"tokens"
+]);
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+function walkAst(node, visitor, parent = null, key = null) {
+	visitor(node, parent, key);
+	for (const [childKey, value] of Object.entries(node)) {
+		if (ignoredKeys.has(childKey)) continue;
+		if (isAstNode(value)) {
+			walkAst(value, visitor, node, childKey);
+		} else if (Array.isArray(value)) {
+			for (const child of value) {
+				if (isAstNode(child)) {
+					walkAst(child, visitor, node, childKey);
+				}
+			}
+		}
+	}
+}
+function findAstNode(root, predicate) {
+	let found = null;
+	walkAst(root, (node, parent, key) => {
+		if (!found && predicate(node, parent, key)) {
+			found = node;
+		}
+	});
+	return found;
+}
+function childNode(node, key) {
+	const value = node[key];
+	return isAstNode(value) ? value : null;
+}
+function childNodes(node, key) {
+	const value = node[key];
+	return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+function identifierName(node) {
+	if (!node || node.type !== "Identifier" && node.type !== "JSXIdentifier") return null;
+	return typeof node.name === "string" ? node.name : null;
+}
+function literalValue(node) {
+	if (!node) return void 0;
+	if (node.type === "Literal" || node.type.endsWith("Literal")) {
+		return node.value;
+	}
+	return void 0;
+}
+function unwrapExpression(node) {
+	let current = node;
+	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression") {
+		const expression = childNode(current, "expression");
+		if (!expression) break;
+		current = expression;
+	}
+	return current;
+}

package/dist/cjs/contracts.cjs

@@ -0,0 +1,62 @@
+
+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 contracts_exports = {};
+__export(contracts_exports, {
+	expressionReference: () => expressionReference,
+	resolutionKey: () => resolutionKey,
+	resolveFromHost: () => resolveFromHost,
+	resolvedModuleId: () => resolvedModuleId,
+	spanOf: () => spanOf,
+	textOfSpan: () => textOfSpan
+});
+module.exports = __toCommonJS(contracts_exports);
+function resolutionKey(importer, specifier) {
+	return `${importer}\0${specifier}`;
+}
+function resolveFromHost(resolutions, specifier, importer) {
+	return resolutions.get(resolutionKey(importer, specifier)) ?? null;
+}
+function resolvedModuleId(id) {
+	const isAbsolute = id.startsWith("/") || id.startsWith("\\") || id.startsWith("\0") || /^[A-Za-z]:[\\/]/.test(id) || /^[A-Za-z][A-Za-z\d+.-]*:\/\//.test(id);
+	if (!isAbsolute) {
+		throw new Error(`Host module id must be canonical and already resolved: ${id}`);
+	}
+	return id;
+}
+function expressionReference(id, node) {
+	return {
+		kind: "expression",
+		id,
+		start: node.start,
+		end: node.end
+	};
+}
+function spanOf(id, node) {
+	return {
+		id,
+		start: node.start,
+		end: node.end
+	};
+}
+function textOfSpan(source, span) {
+	return source.slice(span.start, span.end);
+}

package/dist/cjs/diagnostics.cjs

@@ -0,0 +1,69 @@
+
+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 diagnostics_exports = {};
+__export(diagnostics_exports, {
+	linkedBailout: () => linkedBailout,
+	localBailout: () => localBailout,
+	zeroRuleForBailout: () => zeroRuleForBailout
+});
+module.exports = __toCommonJS(diagnostics_exports);
+const ZERO_RULE_BY_CODE = {
+	"local/invalid-element-call": 2,
+	"local/unsupported-element-name": 2,
+	"local/unsupported-prop-key": 3,
+	"local/unsupported-child": 3,
+	"local/unsupported-expression": 3,
+	"local/unsupported-styled-definition": 3,
+	"local/dynamic-style-value": 3,
+	"local/unsafe-style-spread": 1,
+	"local/unsupported-target": 6,
+	"local/style-resolution-failed": 3,
+	"local/overlapping-edit": 6,
+	"local/non-object-spread": 1,
+	"local/static-evaluation-cycle": 3,
+	"local/parse-error": 3,
+	"linked/unresolved-component-binding": 2,
+	"linked/unresolved-binding": 2,
+	"linked/missing-initializer": 3,
+	"linked/unresolved-import": 2,
+	"linked/unresolved-component-config": 2
+};
+function zeroRuleForBailout(reason) {
+	return reason.zeroRule ?? ZERO_RULE_BY_CODE[reason.code];
+}
+function localBailout(code, span, message) {
+	return {
+		code,
+		kind: "local",
+		message,
+		span
+	};
+}
+function linkedBailout(code, span, message, dependencyId) {
+	return {
+		code,
+		kind: "linked",
+		message,
+		span,
+		dependencyId
+	};
+}

package/dist/cjs/evaluate.cjs

@@ -0,0 +1,351 @@
+
+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 evaluate_exports = {};
+__export(evaluate_exports, {
+	evaluateBinding: () => evaluateBinding,
+	evaluateConditionalExpression: () => evaluateConditionalExpression,
+	evaluateExpression: () => evaluateExpression
+});
+module.exports = __toCommonJS(evaluate_exports);
+var import_ast = require("./ast.cjs");
+var import_contracts = require("./contracts.cjs");
+var import_diagnostics = require("./diagnostics.cjs");
+function success(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function literal(node) {
+	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 unsupported(id, node, detail = `Expression ${node.type} is not statically supported`) {
+	return {
+		ok: false,
+		bailout: (0, import_diagnostics.localBailout)("local/unsupported-expression", (0, import_contracts.spanOf)(id, node), detail)
+	};
+}
+function evaluateDefinition(resolver, definition, useSpan, state) {
+	const key = `${definition.id}:${definition.span.start}`;
+	if (state.activeDefinitions.has(key)) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.localBailout)("local/static-evaluation-cycle", useSpan, `Static evaluation cycle reached ${definition.name}`)
+		};
+	}
+	if (!definition.initializer) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/missing-initializer", useSpan, `Binding ${definition.name} has no static initializer`, definition.id)
+		};
+	}
+	if (!definition.constant) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/unresolved-binding", useSpan, `Binding ${definition.name} is mutable and cannot be statically evaluated`, definition.id)
+		};
+	}
+	const initializer = resolver.expressionNode(definition.initializer);
+	if (!initializer) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/missing-initializer", useSpan, `Binding ${definition.name} initializer is outside the linked graph`, definition.id)
+		};
+	}
+	state.dependencies.add(definition.id);
+	state.activeDefinitions.add(key);
+	try {
+		return evaluateNode(resolver, definition.id, initializer, state);
+	} finally {
+		state.activeDefinitions.delete(key);
+	}
+}
+function evaluateObject(resolver, id, node, state) {
+	const output = {};
+	for (const property of (0, import_ast.childNodes)(node, "properties")) {
+		if (property.type === "SpreadElement") {
+			const argument = (0, import_ast.childNode)(property, "argument");
+			if (!argument) return unsupported(id, property);
+			const spread = evaluateNode(resolver, id, argument, state);
+			if (!spread.ok) return spread;
+			if (!spread.value || typeof spread.value !== "object" || Array.isArray(spread.value)) {
+				return {
+					ok: false,
+					bailout: (0, import_diagnostics.localBailout)("local/non-object-spread", (0, import_contracts.spanOf)(id, property), "Static object spread did not evaluate to an object")
+				};
+			}
+			Object.assign(output, spread.value);
+			continue;
+		}
+		if (property.type !== "Property" && property.type !== "ObjectProperty") {
+			return unsupported(id, property);
+		}
+		const keyNode = (0, import_ast.childNode)(property, "key");
+		const valueNode = (0, import_ast.childNode)(property, "value");
+		if (!keyNode || !valueNode) return unsupported(id, property);
+		let key = (0, import_ast.identifierName)(keyNode) ?? void 0;
+		if (property.computed === true || key === void 0) {
+			const evaluatedKey = evaluateNode(resolver, id, keyNode, state);
+			if (!evaluatedKey.ok) return evaluatedKey;
+			key = evaluatedKey.value;
+		}
+		if (typeof key !== "string" && typeof key !== "number") {
+			return unsupported(id, keyNode, "Static object key is not a string or number");
+		}
+		const value = evaluateNode(resolver, id, valueNode, state);
+		if (!value.ok) return value;
+		output[String(key)] = value.value;
+	}
+	return success(output);
+}
+function evaluateArray(resolver, id, node, state) {
+	const output = [];
+	const rawElements = node.elements;
+	if (!Array.isArray(rawElements) || rawElements.some((element) => element === null || !(0, import_ast.isAstNode)(element))) {
+		return unsupported(id, node, "Sparse arrays are not statically supported");
+	}
+	for (const element of rawElements.filter(import_ast.isAstNode)) {
+		if (element.type === "SpreadElement") {
+			const argument = (0, import_ast.childNode)(element, "argument");
+			if (!argument) return unsupported(id, element);
+			const spread = evaluateNode(resolver, id, argument, state);
+			if (!spread.ok) return spread;
+			if (!Array.isArray(spread.value)) {
+				return unsupported(id, element, "Static array spread did not evaluate to an array");
+			}
+			output.push(...spread.value);
+			continue;
+		}
+		const value = evaluateNode(resolver, id, element, state);
+		if (!value.ok) return value;
+		output.push(value.value);
+	}
+	return success(output);
+}
+function evaluateNode(resolver, id, input, state) {
+	const node = (0, import_ast.unwrapExpression)(input);
+	const literalValue = literal(node);
+	if (literalValue !== void 0) return success(literalValue);
+	switch (node.type) {
+		case "Identifier": {
+			const name = (0, import_ast.identifierName)(node);
+			if (!name) return unsupported(id, node);
+			const definition = resolver.resolveBinding(id, name);
+			if (!definition) {
+				return {
+					ok: false,
+					bailout: (0, import_diagnostics.linkedBailout)("linked/unresolved-binding", (0, import_contracts.spanOf)(id, node), `Binding ${name} has no host-linked definition`)
+				};
+			}
+			return evaluateDefinition(resolver, definition, (0, import_contracts.spanOf)(id, node), state);
+		}
+		case "ObjectExpression": return evaluateObject(resolver, id, node, state);
+		case "ArrayExpression": return evaluateArray(resolver, id, node, state);
+		case "MemberExpression": {
+			const objectNode = (0, import_ast.childNode)(node, "object");
+			const propertyNode = (0, import_ast.childNode)(node, "property");
+			if (!objectNode || !propertyNode) return unsupported(id, node);
+			const object = evaluateNode(resolver, id, objectNode, state);
+			if (!object.ok) return object;
+			let property = (0, import_ast.identifierName)(propertyNode);
+			if (node.computed === true || property === null) {
+				const evaluatedProperty = evaluateNode(resolver, id, propertyNode, state);
+				if (!evaluatedProperty.ok) return evaluatedProperty;
+				property = evaluatedProperty.value;
+			}
+			if ((typeof object.value !== "object" || object.value === null) && typeof object.value !== "string") {
+				return unsupported(id, node, "Static member target is not indexable");
+			}
+			if (typeof property !== "string" && typeof property !== "number") {
+				return unsupported(id, propertyNode, "Static member key is not a string or number");
+			}
+			const value = object.value[String(property)];
+			return value === void 0 ? unsupported(id, node, `Static member ${String(property)} does not exist`) : success(value);
+		}
+		case "UnaryExpression": {
+			const argument = (0, import_ast.childNode)(node, "argument");
+			if (!argument) return unsupported(id, node);
+			const value = evaluateNode(resolver, id, argument, state);
+			if (!value.ok) return value;
+			if (node.operator === "-" && typeof value.value === "number") {
+				return success(-value.value);
+			}
+			if (node.operator === "+" && typeof value.value === "number") {
+				return success(value.value);
+			}
+			if (node.operator === "!") return success(!value.value);
+			return unsupported(id, node, `Unary operator ${String(node.operator)} is unsupported`);
+		}
+		case "BinaryExpression":
+		case "LogicalExpression": {
+			const leftNode = (0, import_ast.childNode)(node, "left");
+			const rightNode = (0, import_ast.childNode)(node, "right");
+			if (!leftNode || !rightNode) return unsupported(id, node);
+			const left = evaluateNode(resolver, id, leftNode, state);
+			if (!left.ok) return left;
+			if (node.type === "LogicalExpression") {
+				if (node.operator === "&&" && !left.value) return left;
+				if (node.operator === "||" && left.value) return left;
+				if (node.operator === "??" && left.value !== null) return left;
+			}
+			const right = evaluateNode(resolver, id, rightNode, state);
+			if (!right.ok) return right;
+			switch (node.operator) {
+				case "+":
+					if (typeof left.value === "number" && typeof right.value === "number") {
+						return success(left.value + right.value);
+					}
+					if (typeof left.value === "string" || typeof right.value === "string") {
+						return success(String(left.value) + String(right.value));
+					}
+					break;
+				case "-":
+					if (typeof left.value === "number" && typeof right.value === "number") {
+						return success(left.value - right.value);
+					}
+					break;
+				case "*":
+					if (typeof left.value === "number" && typeof right.value === "number") {
+						return success(left.value * right.value);
+					}
+					break;
+				case "/":
+					if (typeof left.value === "number" && typeof right.value === "number") {
+						return success(left.value / right.value);
+					}
+					break;
+				case "&&":
+				case "||":
+				case "??": return right;
+			}
+			return unsupported(id, node, `Binary operator ${String(node.operator)} is unsupported`);
+		}
+		case "ConditionalExpression": {
+			const testNode = (0, import_ast.childNode)(node, "test");
+			const consequent = (0, import_ast.childNode)(node, "consequent");
+			const alternate = (0, import_ast.childNode)(node, "alternate");
+			if (!testNode || !consequent || !alternate) return unsupported(id, node);
+			const test = evaluateNode(resolver, id, testNode, state);
+			if (!test.ok) return test;
+			return evaluateNode(resolver, id, test.value ? consequent : alternate, state);
+		}
+		case "TemplateLiteral": {
+			const quasis = (0, import_ast.childNodes)(node, "quasis");
+			const expressions = (0, import_ast.childNodes)(node, "expressions");
+			let output = "";
+			for (let index = 0; index < quasis.length; index++) {
+				const quasi = quasis[index];
+				const cooked = quasi?.value?.cooked;
+				const raw = quasi?.value?.raw;
+				output += typeof cooked === "string" ? cooked : typeof raw === "string" ? raw : "";
+				const expression = expressions[index];
+				if (expression) {
+					const value = evaluateNode(resolver, id, expression, state);
+					if (!value.ok) return value;
+					output += String(value.value);
+				}
+			}
+			return success(output);
+		}
+		default: return unsupported(id, node);
+	}
+}
+function evaluateConditionalExpression(resolver, reference) {
+	const node = resolver.expressionNode(reference);
+	if (!node) return null;
+	const expression = (0, import_ast.unwrapExpression)(node);
+	if (!(0, import_ast.isAstNode)(expression) || expression.type !== "ConditionalExpression") return null;
+	const testNode = (0, import_ast.childNode)(expression, "test");
+	const consequent = (0, import_ast.childNode)(expression, "consequent");
+	const alternate = (0, import_ast.childNode)(expression, "alternate");
+	if (!testNode || !consequent || !alternate) return null;
+	const trueState = {
+		activeDefinitions: /* @__PURE__ */ new Set(),
+		dependencies: /* @__PURE__ */ new Set()
+	};
+	const whenTrue = evaluateNode(resolver, reference.id, consequent, trueState);
+	if (!whenTrue.ok) return null;
+	const falseState = {
+		activeDefinitions: /* @__PURE__ */ new Set(),
+		dependencies: /* @__PURE__ */ new Set()
+	};
+	const whenFalse = evaluateNode(resolver, reference.id, alternate, falseState);
+	if (!whenFalse.ok) return null;
+	return {
+		test: (0, import_contracts.spanOf)(reference.id, testNode),
+		whenTrue: {
+			value: whenTrue.value,
+			dependencies: [...trueState.dependencies].sort()
+		},
+		whenFalse: {
+			value: whenFalse.value,
+			dependencies: [...falseState.dependencies].sort()
+		}
+	};
+}
+function evaluateExpression(resolver, reference) {
+	const node = resolver.expressionNode(reference);
+	if (!node) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/missing-initializer", reference, "Expression is outside the linked project graph", reference.id)
+		};
+	}
+	const state = {
+		activeDefinitions: /* @__PURE__ */ new Set(),
+		dependencies: /* @__PURE__ */ new Set()
+	};
+	const result = evaluateNode(resolver, reference.id, node, state);
+	return result.ok ? {
+		ok: true,
+		value: result.value,
+		dependencies: [...state.dependencies].sort()
+	} : result;
+}
+function evaluateBinding(resolver, id, localName) {
+	const definition = resolver.resolveBinding(id, localName);
+	if (!definition) {
+		const emptySpan = {
+			id,
+			start: 0,
+			end: 0
+		};
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/unresolved-binding", emptySpan, `Binding ${localName} has no host-linked definition`)
+		};
+	}
+	if (!definition.initializer) {
+		return {
+			ok: false,
+			bailout: (0, import_diagnostics.linkedBailout)("linked/missing-initializer", definition.span, `Binding ${localName} has no static initializer`, definition.id)
+		};
+	}
+	return evaluateExpression(resolver, (0, import_contracts.expressionReference)(definition.id, definition.initializer));
+}