@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.1

package/esm/utils/collectOxcTemplateDependencies/expressionExtraction.js

@@ -0,0 +1,496 @@
+import { ValueType } from "@wyw-in-js/shared";
+import { applyOxcReplacements } from "../oxc/replacements.js";
+import { createOxcLocationLookup } from "../oxc/sourceLocations.js";
+import { analyzeProgram, containsTaggedTemplateExpression, createSpanLookup, findReferences, getSourceLocation, isBindingDeclaredWithin, parseOxc, resolveBindingAt } from "./scopeAnalysis.js";
+import { applyExpressionReplacements, collectIdentifierReferenceReplacements, collectStaticNamespaceMemberReferences, getConstantReplacement, replaceIdentifierReferences } from "./expressionReplacements.js";
+import { cloneStaticValue, evaluateStatic, isStaticSerializableValue, literalCode } from "./staticEvaluator.js";
+const allocateExpressionName = (ctx) => {
+	let base = "_exp";
+	let idx = 1;
+	while (ctx.usedNames.has(base)) {
+		idx += 1;
+		base = `_exp${idx}`;
+	}
+	ctx.usedNames.add(base);
+	return base;
+};
+const hoistedBindingKey = (binding) => `${binding.scope.start}:${binding.scope.end}:${binding.declaredAt}:${binding.name}`;
+const allocateHoistedBindingName = (originalName, ctx) => {
+	const sanitized = originalName.replace(/[^A-Za-z0-9_$]/g, "_") || "hoisted";
+	const base = /^[A-Za-z_$]/.test(sanitized) ? `_${sanitized}` : "_hoisted";
+	let candidate = base;
+	let idx = 2;
+	while (ctx.usedNames.has(candidate)) {
+		candidate = `${base}${idx}`;
+		idx += 1;
+	}
+	ctx.usedNames.add(candidate);
+	return candidate;
+};
+const getHoistedBindingName = (binding, ctx) => {
+	const key = hoistedBindingKey(binding);
+	const existing = ctx.hoistedBindingNames.get(key);
+	if (existing) {
+		return existing;
+	}
+	const next = allocateHoistedBindingName(binding.name, ctx);
+	ctx.hoistedBindingNames.set(key, next);
+	return next;
+};
+const parenthesizeStaticReplacement = (source) => `(${source})`;
+const replaceStaticLocalReferences = (expression, replacements, ctx, extraReplacements = []) => {
+	if (expression.type === "Identifier" && extraReplacements.length === 0) {
+		return replacements.get(expression.name) ?? ctx.code.slice(expression.start, expression.end);
+	}
+	const parenthesized = new Map();
+	replacements.forEach((value, key) => {
+		parenthesized.set(key, parenthesizeStaticReplacement(value));
+	});
+	return applyExpressionReplacements(expression, [...extraReplacements, ...collectIdentifierReferenceReplacements(expression, parenthesized)], ctx.code);
+};
+const collectStaticLocalExpression = (expression, ctx, stack = []) => {
+	const replacements = new Map();
+	const importedFrom = new Set();
+	const imports = [];
+	for (const { name, start } of findReferences(expression, ctx.referencesByNode)) {
+		const binding = resolveBindingAt(ctx, name, start);
+		if (!binding) {
+			return null;
+		}
+		if (binding.importedFrom) {
+			importedFrom.add(binding.importedFrom);
+			if (binding.imported && binding.imported !== "*") {
+				imports.push({
+					imported: binding.imported,
+					local: binding.name,
+					source: binding.importedFrom
+				});
+				continue;
+			}
+			return null;
+		}
+		const replacement = getConstantReplacement(binding, ctx);
+		if (replacement) {
+			replacements.set(name, replacement);
+			continue;
+		}
+		if (binding.kind === "param" || binding.declarationKind !== "const" || !binding.declarator?.init || binding.declarator.id.type !== "Identifier") {
+			return null;
+		}
+		// Processor-managed bindings (const x = css``) carry their value
+		// (the generated className string) via inlineConstants at candidate
+		// evaluation time. Walking the TaggedTemplateExpression here would
+		// pull the processor's tag import (e.g. `css` from '@linaria/core')
+		// into the candidate's static imports, where it fails to resolve.
+		// Leave the identifier as a free reference; the candidate-side env
+		// supplies the className.
+		if (binding.declarator.init.type === "TaggedTemplateExpression") {
+			continue;
+		}
+		const key = hoistedBindingKey(binding);
+		if (stack.includes(key)) {
+			return null;
+		}
+		const nested = collectStaticLocalExpression(binding.declarator.init, ctx, [...stack, key]);
+		if (!nested) {
+			return null;
+		}
+		replacements.set(name, nested.source);
+		nested.importedFrom.forEach((source) => importedFrom.add(source));
+		imports.push(...nested.imports);
+	}
+	return {
+		importedFrom: [...importedFrom],
+		imports,
+		source: replacements.size > 0 ? replaceStaticLocalReferences(expression, replacements, ctx) : ctx.code.slice(expression.start, expression.end)
+	};
+};
+const declarationInitCode = (init, ctx) => {
+	const renamedDependencies = new Map();
+	findReferences(init, ctx.referencesByNode).forEach(({ name, start }) => {
+		const dependency = resolveBindingAt(ctx, name, start);
+		if (!dependency || dependency.importedFrom || dependency.isRoot || dependency.declarator?.id.type !== "Identifier") {
+			return;
+		}
+		renamedDependencies.set(name, getHoistedBindingName(dependency, ctx));
+	});
+	return renamedDependencies.size > 0 ? replaceIdentifierReferences(init, renamedDependencies, ctx.code) : ctx.code.slice(init.start, init.end);
+};
+const addHoistedCode = (key, code, ctx) => {
+	if (ctx.hoistedDeclarations.has(key)) {
+		return;
+	}
+	ctx.hoistedDeclarations.set(key, code);
+	const declarations = ctx.hoistedDeclarationsByInsertionPoint.get(ctx.currentInsertionPoint) ?? [];
+	declarations.push(code);
+	ctx.hoistedDeclarationsByInsertionPoint.set(ctx.currentInsertionPoint, declarations);
+};
+const declarationCode = (binding, ctx) => {
+	const { declarator } = binding;
+	if (!declarator) {
+		return "";
+	}
+	const { id } = declarator;
+	if (id.type !== "Identifier") {
+		const idCode = ctx.code.slice(id.start, id.end);
+		if (!declarator.init) {
+			return `let ${idCode};`;
+		}
+		return `let ${idCode} = ${declarationInitCode(declarator.init, ctx)};`;
+	}
+	const hoistedName = getHoistedBindingName(binding, ctx);
+	if (!declarator.init) {
+		return `let ${hoistedName};`;
+	}
+	return `let ${hoistedName} = ${declarationInitCode(declarator.init, ctx)};`;
+};
+const assertHoistable = (binding, ctx, stack = []) => {
+	if (!binding.declarator?.init || binding.importedFrom || binding.isRoot) {
+		return;
+	}
+	if (stack.includes(binding.name)) {
+		return;
+	}
+	const refs = findReferences(binding.declarator.init, ctx.referencesByNode);
+	refs.forEach(({ name, start }) => {
+		const nextBinding = resolveBindingAt(ctx, name, start);
+		if (!nextBinding) {
+			return;
+		}
+		if (nextBinding.kind === "param") {
+			throw new Error(`This identifier cannot be used in the template, because it is a function parameter.`);
+		}
+		assertHoistable(nextBinding, ctx, [...stack, binding.name]);
+	});
+};
+const addHoistedDeclaration = (binding, ctx, stack = []) => {
+	if (!binding.declaration || !binding.declarator || binding.importedFrom || binding.isRoot || stack.includes(binding.name)) {
+		return;
+	}
+	const hoistSource = binding.declarator.init ?? binding.declarator;
+	findReferences(hoistSource, ctx.referencesByNode).forEach(({ name, start }) => {
+		const dependency = resolveBindingAt(ctx, name, start);
+		if (dependency) {
+			addHoistedDeclaration(dependency, ctx, [...stack, binding.name]);
+		}
+	});
+	if (!ctx.hoistedDeclarations.has(binding.name)) {
+		addHoistedCode(binding.name, declarationCode(binding, ctx), ctx);
+	}
+};
+const literalExpressionValue = (expression, ctx) => {
+	if (expression.type !== "Literal") {
+		return null;
+	}
+	if (expression.value !== null && typeof expression.value !== "string" && typeof expression.value !== "number" && typeof expression.value !== "boolean") {
+		return null;
+	}
+	let type;
+	if (expression.value === null) {
+		type = "NullLiteral";
+	} else if (typeof expression.value === "string") {
+		type = "StringLiteral";
+	} else if (typeof expression.value === "number") {
+		type = "NumericLiteral";
+	} else {
+		type = "BooleanLiteral";
+	}
+	const loc = getSourceLocation(expression.start, expression.end, ctx);
+	const ex = expression.value === null ? {
+		loc,
+		type
+	} : {
+		loc,
+		type,
+		value: expression.value
+	};
+	return {
+		ex,
+		kind: ValueType.CONST,
+		source: ctx.code.slice(expression.start, expression.end),
+		value: expression.value
+	};
+};
+const extractExpression = (expression, ctx, evaluate) => {
+	const source = ctx.code.slice(expression.start, expression.end);
+	// Only inline function expressions are function-valued here. A bare
+	// identifier that points to a local function may be a styled runtime
+	// component, so it has to stay as a lazy `_exp()` reference.
+	const isFunction = expression.type === "FunctionExpression" || expression.type === "ArrowFunctionExpression";
+	if (evaluate) {
+		const evaluated = evaluateStatic(expression, ctx);
+		const literal = literalCode(evaluated);
+		if (literal) {
+			findReferences(expression, ctx.referencesByNode).forEach(({ name }) => ctx.dependencyNames.add(name));
+			return {
+				expressionCode: literal,
+				importedFrom: [],
+				kind: isFunction ? ValueType.FUNCTION : ValueType.LAZY,
+				staticImports: [],
+				staticValue: isStaticSerializableValue(evaluated) ? cloneStaticValue(evaluated) : undefined
+			};
+		}
+	}
+	const identifierReplacements = new Map();
+	const importedFrom = [];
+	const namespaceStatic = collectStaticNamespaceMemberReferences(expression, ctx);
+	const staticIdentifierReplacements = new Map();
+	const staticImports = [...namespaceStatic.imports];
+	let hasNonStaticLocalReference = false;
+	let hasInlinableLocalReference = false;
+	findReferences(expression, ctx.referencesByNode).forEach(({ name, start }) => {
+		const binding = resolveBindingAt(ctx, name, start);
+		if (!binding) {
+			return;
+		}
+		if (isFunction && isBindingDeclaredWithin(binding, expression)) {
+			return;
+		}
+		ctx.dependencyNames.add(name);
+		if (binding.importedFrom) {
+			importedFrom.push(binding.importedFrom);
+			if (binding.imported && binding.imported !== "*") {
+				staticImports.push({
+					imported: binding.imported,
+					local: binding.name,
+					source: binding.importedFrom
+				});
+			} else if (binding.imported === "*" && namespaceStatic.coveredReferenceStarts.has(start)) {} else {
+				hasNonStaticLocalReference = true;
+			}
+			return;
+		}
+		const replacement = getConstantReplacement(binding, ctx);
+		if (evaluate && replacement) {
+			identifierReplacements.set(name, replacement);
+			return;
+		}
+		const init = binding.declarator?.init;
+		// Processor-managed bindings (`const x = css```, or object literals
+		// containing processor tags) carry values that only become known after
+		// processors run. Leave the identifier free in the candidate source so
+		// the resolver can supply it via inlineConstants at evaluation time.
+		const isProcessorManagedLocal = !!evaluate && !!init && containsTaggedTemplateExpression(init);
+		const staticLocalExpression = evaluate && init && !isProcessorManagedLocal ? collectStaticLocalExpression(init, ctx, [hoistedBindingKey(binding)]) : null;
+		if (staticLocalExpression) {
+			staticIdentifierReplacements.set(name, staticLocalExpression.source);
+			importedFrom.push(...staticLocalExpression.importedFrom);
+			staticImports.push(...staticLocalExpression.imports);
+		} else if (isProcessorManagedLocal) {
+			hasInlinableLocalReference = true;
+		} else {
+			hasNonStaticLocalReference = true;
+		}
+		assertHoistable(binding, ctx);
+		addHoistedDeclaration(binding, ctx);
+		if (!binding.isRoot && binding.declarator?.id.type === "Identifier") {
+			identifierReplacements.set(name, getHoistedBindingName(binding, ctx));
+		}
+	});
+	// Merge literal-const inlines (e.g. `const A = 32` -> "32") with
+	// local-to-imported substitutions (e.g. `const X = imp.y` -> "imp.y").
+	// Both must reach the candidate source so the resolver's evaluator
+	// can fold every Identifier in the expression; env only carries
+	// imported bindings, never same-file locals.
+	const mergedReplacements = new Map(staticIdentifierReplacements);
+	identifierReplacements.forEach((value, key) => {
+		if (!mergedReplacements.has(key)) {
+			mergedReplacements.set(key, value);
+		}
+	});
+	let staticExpressionCode;
+	if (mergedReplacements.size > 0) {
+		staticExpressionCode = replaceStaticLocalReferences(expression, mergedReplacements, ctx, namespaceStatic.replacements);
+	} else if (namespaceStatic.replacements.length > 0) {
+		staticExpressionCode = applyExpressionReplacements(expression, namespaceStatic.replacements, ctx.code);
+	}
+	return {
+		expressionCode: identifierReplacements.size > 0 ? replaceIdentifierReferences(expression, identifierReplacements, ctx.code) : source,
+		importedFrom,
+		kind: isFunction ? ValueType.FUNCTION : ValueType.LAZY,
+		staticExpressionCode,
+		hasInlinableLocalReference: !hasNonStaticLocalReference && hasInlinableLocalReference,
+		staticImports: hasNonStaticLocalReference ? [] : staticImports
+	};
+};
+const getInsertionPoints = (program, expressions) => {
+	if (expressions.length === 0) {
+		return [];
+	}
+	if (program.body.length === 0) {
+		return expressions.map(() => 0);
+	}
+	const insertionPoints = [];
+	let ownerIndex = 0;
+	expressions.forEach((expression) => {
+		while (ownerIndex < program.body.length - 1 && program.body[ownerIndex].end < expression.start) {
+			ownerIndex += 1;
+		}
+		let owner = program.body[ownerIndex];
+		if (!owner || owner.start > expression.start || owner.end < expression.end) {
+			owner = program.body.find((statement) => statement.start <= expression.start && statement.end >= expression.end);
+		}
+		insertionPoints.push(owner?.start ?? 0);
+	});
+	return insertionPoints;
+};
+const extractExpressions = (code, filename, evaluate, program, analysis, expressions, staticBindings) => {
+	if (expressions.length === 0) {
+		return {
+			code,
+			dependencyNames: [],
+			expressionValues: [],
+			staticValueCandidates: [],
+			staticValues: []
+		};
+	}
+	const insertionPoints = getInsertionPoints(program, expressions);
+	const ctx = {
+		bindingResolutionCache: new Map(),
+		bindingsByName: analysis.bindingsByName,
+		code,
+		currentInsertionPoint: insertionPoints[0] ?? 0,
+		currentExpressionStart: expressions[0].start,
+		dependencyNames: new Set(),
+		expressionValues: [],
+		filename,
+		hoistedBindingNames: new Map(),
+		hoistedDeclarations: new Map(),
+		hoistedDeclarationsByInsertionPoint: new Map(),
+		loc: createOxcLocationLookup(code),
+		referencesByNode: new WeakMap(),
+		replacements: [],
+		rootMutationsByBinding: analysis.rootMutationsByBinding,
+		staticBindings,
+		staticImportAliases: new Map(),
+		staticValueCandidates: [],
+		staticValues: [],
+		usedNames: new Set(analysis.usedNames)
+	};
+	expressions.forEach((expression, index) => {
+		ctx.currentInsertionPoint = insertionPoints[index] ?? 0;
+		ctx.currentExpressionStart = expression.start;
+		const literal = literalExpressionValue(expression, ctx);
+		if (literal) {
+			ctx.expressionValues.push(literal);
+			return;
+		}
+		const { expressionCode, hasInlinableLocalReference, importedFrom, kind, staticExpressionCode, staticImports, staticValue } = extractExpression(expression, ctx, evaluate);
+		const expName = allocateExpressionName(ctx);
+		addHoistedCode(expName, `const ${expName} = () => (${expressionCode});`, ctx);
+		if (staticValue !== undefined && kind !== ValueType.FUNCTION) {
+			ctx.staticValues.push({
+				name: expName,
+				value: staticValue
+			});
+		} else if ((staticImports.length > 0 || hasInlinableLocalReference || staticExpressionCode !== undefined) && kind !== ValueType.FUNCTION) {
+			const uniqueImports = new Map();
+			staticImports.forEach((item) => {
+				uniqueImports.set(`${item.local}\0${item.importLocal ?? ""}\0${item.source}\0${item.imported}`, item);
+			});
+			ctx.staticValueCandidates.push({
+				imports: [...uniqueImports.values()],
+				name: expName,
+				source: staticExpressionCode ?? expressionCode
+			});
+		}
+		ctx.replacements.push({
+			start: expression.start,
+			end: expression.end,
+			value: `${expName}()`
+		});
+		ctx.expressionValues.push({
+			ex: {
+				loc: getSourceLocation(expression.start, expression.end, ctx),
+				name: expName,
+				type: "Identifier"
+			},
+			importedFrom,
+			kind,
+			source: ctx.code.slice(expression.start, expression.end)
+		});
+	});
+	ctx.hoistedDeclarationsByInsertionPoint.forEach((declarations, point) => {
+		ctx.replacements.push({
+			start: point,
+			end: point,
+			value: `${declarations.join("\n")}\n`
+		});
+	});
+	return {
+		code: applyOxcReplacements(code, ctx.replacements),
+		dependencyNames: [...ctx.dependencyNames],
+		expressionValues: ctx.expressionValues,
+		staticValueCandidates: ctx.staticValueCandidates,
+		staticValues: ctx.staticValues
+	};
+};
+export const isOxcStaticSerializableValue = (value) => isStaticSerializableValue(value);
+export const evaluateOxcStaticExpressionAt = (code, filename, expressionSpan, env = new Map(), staticBindings) => {
+	const program = parseOxc(code, filename);
+	const analysis = analyzeProgram(program, {
+		collectTargetExpressions: true,
+		expressionSpanLookup: createSpanLookup([expressionSpan])
+	});
+	const [expression] = analysis.targetExpressions;
+	if (!expression) {
+		return undefined;
+	}
+	const ctx = {
+		bindingResolutionCache: new Map(),
+		bindingsByName: analysis.bindingsByName,
+		code,
+		currentInsertionPoint: 0,
+		currentExpressionStart: expression.start,
+		dependencyNames: new Set(),
+		expressionValues: [],
+		filename,
+		hoistedBindingNames: new Map(),
+		hoistedDeclarations: new Map(),
+		hoistedDeclarationsByInsertionPoint: new Map(),
+		loc: createOxcLocationLookup(code),
+		referencesByNode: new WeakMap(),
+		replacements: [],
+		rootMutationsByBinding: analysis.rootMutationsByBinding,
+		staticBindings,
+		staticImportAliases: new Map(),
+		staticValueCandidates: [],
+		staticValues: [],
+		usedNames: new Set(analysis.usedNames)
+	};
+	return evaluateStatic(expression, ctx, new Map(env));
+};
+export const evaluateOxcStaticExpression = (source, filename, env = new Map(), staticBindings) => {
+	const code = `const __wyw_static_value = ${source};`;
+	const program = parseOxc(code, filename);
+	const declaration = program.body[0];
+	if (declaration?.type !== "VariableDeclaration") {
+		return undefined;
+	}
+	const [declarator] = declaration.declarations;
+	if (!declarator?.init) {
+		return undefined;
+	}
+	return evaluateOxcStaticExpressionAt(code, filename, {
+		end: declarator.init.end,
+		start: declarator.init.start
+	}, env, staticBindings);
+};
+export const collectOxcExpressionDependencies = (code, filename, evaluate = false, targetExpressionSpans, staticBindings) => {
+	const program = parseOxc(code, filename);
+	const analysis = analyzeProgram(program, {
+		collectTargetExpressions: true,
+		expressionSpanLookup: createSpanLookup(targetExpressionSpans)
+	});
+	return extractExpressions(code, filename, evaluate, program, analysis, analysis.targetExpressions, staticBindings);
+};
+export const collectOxcTemplateDependencies = (code, filename, evaluate = false, targetTemplateSpans) => {
+	const program = parseOxc(code, filename);
+	const analysis = analyzeProgram(program, {
+		collectTemplateLiterals: true,
+		templateSpanLookup: createSpanLookup(targetTemplateSpans)
+	});
+	const expressions = analysis.templateLiterals.flatMap((template) => template.expressions);
+	return extractExpressions(code, filename, evaluate, program, analysis, expressions);
+};
+//# sourceMappingURL=expressionExtraction.js.map

package/esm/utils/collectOxcTemplateDependencies/expressionExtraction.js.map

@@ -0,0 +1 @@
+{"mappings":"AAGA,SAAS,iBAAiB;AAG1B,SAAS,4BAA4B;AACrC,SAAS,+BAA+B;AACxC,SACE,gBACA,kCACA,kBACA,gBACA,mBACA,yBACA,UACA,wBACK;AACP,SACE,6BACA,wCACA,wCACA,wBACA,mCACK;AACP,SACE,kBACA,gBACA,2BACA,mBACK;AAcP,MAAM,0BAA0B,QAAmC;CACjE,IAAI,OAAO;CACX,IAAI,MAAM;AACV,QAAO,IAAI,UAAU,IAAI,KAAK,EAAE;AAC9B,SAAO;AACP,SAAO,OAAO;;AAGhB,KAAI,UAAU,IAAI,KAAK;AACvB,QAAO;;AAGT,MAAM,qBAAqB,YACzB,GAAG,QAAQ,MAAM,MAAM,GAAG,QAAQ,MAAM,IAAI,GAAG,QAAQ,WAAW,GAAG,QAAQ;AAE/E,MAAM,8BACJ,cACA,QACW;CACX,MAAM,YAAY,aAAa,QAAQ,mBAAmB,IAAI,IAAI;CAClE,MAAM,OAAO,cAAc,KAAK,UAAU,GAAG,IAAI,cAAc;CAC/D,IAAI,YAAY;CAChB,IAAI,MAAM;AAEV,QAAO,IAAI,UAAU,IAAI,UAAU,EAAE;AACnC,cAAY,GAAG,OAAO;AACtB,SAAO;;AAGT,KAAI,UAAU,IAAI,UAAU;AAC5B,QAAO;;AAGT,MAAM,yBACJ,SACA,QACW;CACX,MAAM,MAAM,kBAAkB,QAAQ;CACtC,MAAM,WAAW,IAAI,oBAAoB,IAAI,IAAI;AACjD,KAAI,UAAU;AACZ,SAAO;;CAGT,MAAM,OAAO,2BAA2B,QAAQ,MAAM,IAAI;AAC1D,KAAI,oBAAoB,IAAI,KAAK,KAAK;AACtC,QAAO;;AAGT,MAAM,iCAAiC,WAA2B,IAAI,OAAO;AAE7E,MAAM,gCACJ,YACA,cACA,KACA,oBAAmC,EAAE,KAC1B;AACX,KAAI,WAAW,SAAS,gBAAgB,kBAAkB,WAAW,GAAG;AACtE,SACE,aAAa,IAAI,WAAW,KAAK,IACjC,IAAI,KAAK,MAAM,WAAW,OAAO,WAAW,IAAI;;CAIpD,MAAM,gBAAgB,IAAI,KAAqB;AAC/C,cAAa,SAAS,OAAO,QAAQ;AACnC,gBAAc,IAAI,KAAK,8BAA8B,MAAM,CAAC;GAC5D;AAEF,QAAO,4BACL,YACA,CACE,GAAG,mBACH,GAAG,uCAAuC,YAAY,cAAc,CACrE,EACD,IAAI,KACL;;AAGH,MAAM,gCACJ,YACA,KACA,QAAkB,EAAE,KACa;CACjC,MAAM,eAAe,IAAI,KAAqB;CAC9C,MAAM,eAAe,IAAI,KAAa;CACtC,MAAM,UAAsC,EAAE;AAE9C,MAAK,MAAM,EAAE,MAAM,WAAW,eAC5B,YACA,IAAI,iBACL,EAAE;EACD,MAAM,UAAU,iBAAiB,KAAK,MAAM,MAAM;AAClD,MAAI,CAAC,SAAS;AACZ,UAAO;;AAGT,MAAI,QAAQ,cAAc;AACxB,gBAAa,IAAI,QAAQ,aAAa;AACtC,OAAI,QAAQ,YAAY,QAAQ,aAAa,KAAK;AAChD,YAAQ,KAAK;KACX,UAAU,QAAQ;KAClB,OAAO,QAAQ;KACf,QAAQ,QAAQ;KACjB,CAAC;AACF;;AAGF,UAAO;;EAGT,MAAM,cAAc,uBAAuB,SAAS,IAAI;AACxD,MAAI,aAAa;AACf,gBAAa,IAAI,MAAM,YAAY;AACnC;;AAGF,MACE,QAAQ,SAAS,WACjB,QAAQ,oBAAoB,WAC5B,CAAC,QAAQ,YAAY,QACrB,QAAQ,WAAW,GAAG,SAAS,cAC/B;AACA,UAAO;;;;;;;;;AAUT,MAAI,QAAQ,WAAW,KAAK,SAAS,4BAA4B;AAC/D;;EAGF,MAAM,MAAM,kBAAkB,QAAQ;AACtC,MAAI,MAAM,SAAS,IAAI,EAAE;AACvB,UAAO;;EAGT,MAAM,SAAS,6BAA6B,QAAQ,WAAW,MAAM,KAAK,CACxE,GAAG,OACH,IACD,CAAC;AACF,MAAI,CAAC,QAAQ;AACX,UAAO;;AAGT,eAAa,IAAI,MAAM,OAAO,OAAO;AACrC,SAAO,aAAa,SAAS,WAAW,aAAa,IAAI,OAAO,CAAC;AACjE,UAAQ,KAAK,GAAG,OAAO,QAAQ;;AAGjC,QAAO;EACL,cAAc,CAAC,GAAG,aAAa;EAC/B;EACA,QACE,aAAa,OAAO,IAChB,6BAA6B,YAAY,cAAc,IAAI,GAC3D,IAAI,KAAK,MAAM,WAAW,OAAO,WAAW,IAAI;EACvD;;AAGH,MAAM,uBACJ,MACA,QACW;CACX,MAAM,sBAAsB,IAAI,KAAqB;AACrD,gBAAe,MAAM,IAAI,iBAAiB,CAAC,SAAS,EAAE,MAAM,YAAY;EACtE,MAAM,aAAa,iBAAiB,KAAK,MAAM,MAAM;AACrD,MACE,CAAC,cACD,WAAW,gBACX,WAAW,UACX,WAAW,YAAY,GAAG,SAAS,cACnC;AACA;;AAGF,sBAAoB,IAAI,MAAM,sBAAsB,YAAY,IAAI,CAAC;GACrE;AAEF,QAAO,oBAAoB,OAAO,IAC9B,4BAA4B,MAAM,qBAAqB,IAAI,KAAK,GAChE,IAAI,KAAK,MAAM,KAAK,OAAO,KAAK,IAAI;;AAG1C,MAAM,kBACJ,KACA,MACA,QACS;AACT,KAAI,IAAI,oBAAoB,IAAI,IAAI,EAAE;AACpC;;AAGF,KAAI,oBAAoB,IAAI,KAAK,KAAK;CACtC,MAAM,eACJ,IAAI,oCAAoC,IAAI,IAAI,sBAAsB,IACtE,EAAE;AACJ,cAAa,KAAK,KAAK;AACvB,KAAI,oCAAoC,IACtC,IAAI,uBACJ,aACD;;AAGH,MAAM,mBAAmB,SAAkB,QAAmC;CAC5E,MAAM,EAAE,eAAe;AACvB,KAAI,CAAC,YAAY;AACf,SAAO;;CAGT,MAAM,EAAE,OAAO;AACf,KAAI,GAAG,SAAS,cAAc;EAC5B,MAAM,SAAS,IAAI,KAAK,MAAM,GAAG,OAAO,GAAG,IAAI;AAC/C,MAAI,CAAC,WAAW,MAAM;AACpB,UAAO,OAAO,OAAO;;AAGvB,SAAO,OAAO,OAAO,KAAK,oBAAoB,WAAW,MAAM,IAAI,CAAC;;CAGtE,MAAM,cAAc,sBAAsB,SAAS,IAAI;AACvD,KAAI,CAAC,WAAW,MAAM;AACpB,SAAO,OAAO,YAAY;;AAG5B,QAAO,OAAO,YAAY,KAAK,oBAAoB,WAAW,MAAM,IAAI,CAAC;;AAG3E,MAAM,mBACJ,SACA,KACA,QAAkB,EAAE,KACX;AACT,KAAI,CAAC,QAAQ,YAAY,QAAQ,QAAQ,gBAAgB,QAAQ,QAAQ;AACvE;;AAGF,KAAI,MAAM,SAAS,QAAQ,KAAK,EAAE;AAChC;;CAGF,MAAM,OAAO,eAAe,QAAQ,WAAW,MAAM,IAAI,iBAAiB;AAC1E,MAAK,SAAS,EAAE,MAAM,YAAY;EAChC,MAAM,cAAc,iBAAiB,KAAK,MAAM,MAAM;AACtD,MAAI,CAAC,aAAa;AAChB;;AAGF,MAAI,YAAY,SAAS,SAAS;AAChC,SAAM,IAAI,MACR,sFACD;;AAGH,kBAAgB,aAAa,KAAK,CAAC,GAAG,OAAO,QAAQ,KAAK,CAAC;GAC3D;;AAGJ,MAAM,yBACJ,SACA,KACA,QAAkB,EAAE,KACX;AACT,KACE,CAAC,QAAQ,eACT,CAAC,QAAQ,cACT,QAAQ,gBACR,QAAQ,UACR,MAAM,SAAS,QAAQ,KAAK,EAC5B;AACA;;CAGF,MAAM,cAAc,QAAQ,WAAW,QAAQ,QAAQ;AACvD,gBAAe,aAAa,IAAI,iBAAiB,CAAC,SAC/C,EAAE,MAAM,YAAY;EACnB,MAAM,aAAa,iBAAiB,KAAK,MAAM,MAAM;AACrD,MAAI,YAAY;AACd,yBAAsB,YAAY,KAAK,CAAC,GAAG,OAAO,QAAQ,KAAK,CAAC;;GAGrE;AAED,KAAI,CAAC,IAAI,oBAAoB,IAAI,QAAQ,KAAK,EAAE;AAC9C,iBAAe,QAAQ,MAAM,gBAAgB,SAAS,IAAI,EAAE,IAAI;;;AAIpE,MAAM,0BACJ,YACA,QACwD;AACxD,KAAI,WAAW,SAAS,WAAW;AACjC,SAAO;;AAGT,KACE,WAAW,UAAU,QACrB,OAAO,WAAW,UAAU,YAC5B,OAAO,WAAW,UAAU,YAC5B,OAAO,WAAW,UAAU,WAC5B;AACA,SAAO;;CAGT,IAAI;AAKJ,KAAI,WAAW,UAAU,MAAM;AAC7B,SAAO;YACE,OAAO,WAAW,UAAU,UAAU;AAC/C,SAAO;YACE,OAAO,WAAW,UAAU,UAAU;AAC/C,SAAO;QACF;AACL,SAAO;;CAGT,MAAM,MAAM,kBAAkB,WAAW,OAAO,WAAW,KAAK,IAAI;CACpE,MAAM,KACJ,WAAW,UAAU,OACjB;EAAE;EAAK;EAAM,GACb;EACE;EACA;EACA,OAAO,WAAW;EACnB;AAEP,QAAO;EACL;EACA,MAAM,UAAU;EAChB,QAAQ,IAAI,KAAK,MAAM,WAAW,OAAO,WAAW,IAAI;EACxD,OAAO,WAAW;EACnB;;AAGH,MAAM,qBACJ,YACA,KACA,aACwB;CACxB,MAAM,SAAS,IAAI,KAAK,MAAM,WAAW,OAAO,WAAW,IAAI;;;;CAI/D,MAAM,aACJ,WAAW,SAAS,wBACpB,WAAW,SAAS;AAEtB,KAAI,UAAU;EACZ,MAAM,YAAY,eAAe,YAAY,IAAI;EACjD,MAAM,UAAU,YAAY,UAAU;AACtC,MAAI,SAAS;AACX,kBAAe,YAAY,IAAI,iBAAiB,CAAC,SAAS,EAAE,WAC1D,IAAI,gBAAgB,IAAI,KAAK,CAC9B;AACD,UAAO;IACL,gBAAgB;IAChB,cAAc,EAAE;IAChB,MAAM,aAAa,UAAU,WAAW,UAAU;IAClD,eAAe,EAAE;IACjB,aAAa,0BAA0B,UAAU,GAC7C,iBAAiB,UAAU,GAC3B;IACL;;;CAIL,MAAM,yBAAyB,IAAI,KAAqB;CACxD,MAAM,eAAyB,EAAE;CACjC,MAAM,kBAAkB,uCACtB,YACA,IACD;CACD,MAAM,+BAA+B,IAAI,KAAqB;CAC9D,MAAM,gBAA4C,CAChD,GAAG,gBAAgB,QACpB;CACD,IAAI,6BAA6B;CACjC,IAAI,6BAA6B;AAEjC,gBAAe,YAAY,IAAI,iBAAiB,CAAC,SAC9C,EAAE,MAAM,YAAY;EACnB,MAAM,UAAU,iBAAiB,KAAK,MAAM,MAAM;AAClD,MAAI,CAAC,SAAS;AACZ;;AAGF,MAAI,cAAc,wBAAwB,SAAS,WAAW,EAAE;AAC9D;;AAGF,MAAI,gBAAgB,IAAI,KAAK;AAE7B,MAAI,QAAQ,cAAc;AACxB,gBAAa,KAAK,QAAQ,aAAa;AACvC,OAAI,QAAQ,YAAY,QAAQ,aAAa,KAAK;AAChD,kBAAc,KAAK;KACjB,UAAU,QAAQ;KAClB,OAAO,QAAQ;KACf,QAAQ,QAAQ;KACjB,CAAC;cAEF,QAAQ,aAAa,OACrB,gBAAgB,uBAAuB,IAAI,MAAM,EACjD,QAGK;AACL,iCAA6B;;AAE/B;;EAGF,MAAM,cAAc,uBAAuB,SAAS,IAAI;AACxD,MAAI,YAAY,aAAa;AAC3B,0BAAuB,IAAI,MAAM,YAAY;AAC7C;;EAGF,MAAM,OAAO,QAAQ,YAAY;;;;;EAKjC,MAAM,0BACJ,CAAC,CAAC,YAAY,CAAC,CAAC,QAAQ,iCAAiC,KAAK;EAChE,MAAM,wBACJ,YAAY,QAAQ,CAAC,0BACjB,6BAA6B,MAAM,KAAK,CACtC,kBAAkB,QAAQ,CAC3B,CAAC,GACF;AACN,MAAI,uBAAuB;AACzB,gCAA6B,IAAI,MAAM,sBAAsB,OAAO;AACpE,gBAAa,KAAK,GAAG,sBAAsB,aAAa;AACxD,iBAAc,KAAK,GAAG,sBAAsB,QAAQ;aAC3C,yBAAyB;AAClC,gCAA6B;SACxB;AACL,gCAA6B;;AAG/B,kBAAgB,SAAS,IAAI;AAC7B,wBAAsB,SAAS,IAAI;AACnC,MAAI,CAAC,QAAQ,UAAU,QAAQ,YAAY,GAAG,SAAS,cAAc;AACnE,0BAAuB,IAAI,MAAM,sBAAsB,SAAS,IAAI,CAAC;;GAG1E;;;;;;CAOD,MAAM,qBAAqB,IAAI,IAAI,6BAA6B;AAChE,wBAAuB,SAAS,OAAO,QAAQ;AAC7C,MAAI,CAAC,mBAAmB,IAAI,IAAI,EAAE;AAChC,sBAAmB,IAAI,KAAK,MAAM;;GAEpC;CAEF,IAAI;AACJ,KAAI,mBAAmB,OAAO,GAAG;AAC/B,yBAAuB,6BACrB,YACA,oBACA,KACA,gBAAgB,aACjB;YACQ,gBAAgB,aAAa,SAAS,GAAG;AAClD,yBAAuB,4BACrB,YACA,gBAAgB,cAChB,IAAI,KACL;;AAGH,QAAO;EACL,gBACE,uBAAuB,OAAO,IAC1B,4BACE,YACA,wBACA,IAAI,KACL,GACD;EACN;EACA,MAAM,aAAa,UAAU,WAAW,UAAU;EAClD;EACA,4BACE,CAAC,8BAA8B;EACjC,eAAe,6BAA6B,EAAE,GAAG;EAClD;;AAGH,MAAM,sBACJ,SACA,gBACa;AACb,KAAI,YAAY,WAAW,GAAG;AAC5B,SAAO,EAAE;;AAGX,KAAI,QAAQ,KAAK,WAAW,GAAG;AAC7B,SAAO,YAAY,UAAU,EAAE;;CAGjC,MAAM,kBAA4B,EAAE;CACpC,IAAI,aAAa;AAEjB,aAAY,SAAS,eAAe;AAClC,SACE,aAAa,QAAQ,KAAK,SAAS,KACnC,QAAQ,KAAK,YAAa,MAAM,WAAW,OAC3C;AACA,iBAAc;;EAGhB,IAAI,QAA6C,QAAQ,KAAK;AAC9D,MACE,CAAC,SACD,MAAM,QAAQ,WAAW,SACzB,MAAM,MAAM,WAAW,KACvB;AACA,WAAQ,QAAQ,KAAK,MAClB,cACC,UAAU,SAAS,WAAW,SAAS,UAAU,OAAO,WAAW,IACtE;;AAGH,kBAAgB,KAAK,OAAO,SAAS,EAAE;GACvC;AAEF,QAAO;;AAGT,MAAM,sBACJ,MACA,UACA,UACA,SACA,UAIA,aACA,mBAC6B;AAC7B,KAAI,YAAY,WAAW,GAAG;AAC5B,SAAO;GACL;GACA,iBAAiB,EAAE;GACnB,kBAAkB,EAAE;GACpB,uBAAuB,EAAE;GACzB,cAAc,EAAE;GACjB;;CAGH,MAAM,kBAAkB,mBAAmB,SAAS,YAAY;CAChE,MAAM,MAAyB;EAC7B,wBAAwB,IAAI,KAAK;EACjC,gBAAgB,SAAS;EACzB;EACA,uBAAuB,gBAAgB,MAAM;EAC7C,wBAAwB,YAAY,GAAG;EACvC,iBAAiB,IAAI,KAAK;EAC1B,kBAAkB,EAAE;EACpB;EACA,qBAAqB,IAAI,KAAK;EAC9B,qBAAqB,IAAI,KAAK;EAC9B,qCAAqC,IAAI,KAAK;EAC9C,KAAK,wBAAwB,KAAK;EAClC,kBAAkB,IAAI,SAAS;EAC/B,cAAc,EAAE;EAChB,wBAAwB,SAAS;EACjC;EACA,qBAAqB,IAAI,KAAK;EAC9B,uBAAuB,EAAE;EACzB,cAAc,EAAE;EAChB,WAAW,IAAI,IAAI,SAAS,UAAU;EACvC;AAED,aAAY,SAAS,YAAY,UAAU;AACzC,MAAI,wBAAwB,gBAAgB,UAAU;AACtD,MAAI,yBAAyB,WAAW;EAExC,MAAM,UAAU,uBAAuB,YAAY,IAAI;AACvD,MAAI,SAAS;AACX,OAAI,iBAAiB,KAAK,QAAQ;AAClC;;EAGF,MAAM,EACJ,gBACA,4BACA,cACA,MACA,sBACA,eACA,gBACE,kBAAkB,YAAY,KAAK,SAAS;EAChD,MAAM,UAAU,uBAAuB,IAAI;AAE3C,iBACE,SACA,SAAS,QAAQ,YAAY,eAAe,KAC5C,IACD;AACD,MAAI,gBAAgB,aAAa,SAAS,UAAU,UAAU;AAC5D,OAAI,aAAa,KAAK;IACpB,MAAM;IACN,OAAO;IACR,CAAC;cAED,cAAc,SAAS,KACtB,8BACA,yBAAyB,cAC3B,SAAS,UAAU,UACnB;GACA,MAAM,gBAAgB,IAAI,KAAuC;AACjE,iBAAc,SAAS,SAAS;AAC9B,kBAAc,IACZ,GAAG,KAAK,MAAM,IAAI,KAAK,eAAe,GAAG,IAAI,KAAK,OAAO,IACvD,KAAK,YAEP,KACD;KACD;AACF,OAAI,sBAAsB,KAAK;IAC7B,SAAS,CAAC,GAAG,cAAc,QAAQ,CAAC;IACpC,MAAM;IACN,QAAQ,wBAAwB;IACjC,CAAC;;AAEJ,MAAI,aAAa,KAAK;GACpB,OAAO,WAAW;GAClB,KAAK,WAAW;GAChB,OAAO,GAAG,QAAQ;GACnB,CAAC;AACF,MAAI,iBAAiB,KAAK;GACxB,IAAI;IACF,KAAK,kBAAkB,WAAW,OAAO,WAAW,KAAK,IAAI;IAC7D,MAAM;IACN,MAAM;IACP;GACD;GACA;GACA,QAAQ,IAAI,KAAK,MAAM,WAAW,OAAO,WAAW,IAAI;GACzD,CAA4D;GAC7D;AAEF,KAAI,oCAAoC,SAAS,cAAc,UAAU;AACvE,MAAI,aAAa,KAAK;GACpB,OAAO;GACP,KAAK;GACL,OAAO,GAAG,aAAa,KAAK,KAAK,CAAC;GACnC,CAAC;GACF;AAEF,QAAO;EACL,MAAM,qBAAqB,MAAM,IAAI,aAAa;EAClD,iBAAiB,CAAC,GAAG,IAAI,gBAAgB;EACzC,kBAAkB,IAAI;EACtB,uBAAuB,IAAI;EAC3B,cAAc,IAAI;EACnB;;AAGH,OAAO,MAAM,gCAAgC,UAC3C,0BAA0B,MAAM;AAElC,OAAO,MAAM,iCACX,MACA,UACA,gBACA,MAA4B,IAAI,KAAK,EACrC,mBACwB;CACxB,MAAM,UAAU,SAAS,MAAM,SAAS;CACxC,MAAM,WAAW,eAAe,SAAS;EACvC,0BAA0B;EAC1B,sBAAsB,iBAAiB,CAAC,eAAe,CAAC;EACzD,CAAC;CACF,MAAM,CAAC,cAAc,SAAS;AAC9B,KAAI,CAAC,YAAY;AACf,SAAO;;CAGT,MAAM,MAAyB;EAC7B,wBAAwB,IAAI,KAAK;EACjC,gBAAgB,SAAS;EACzB;EACA,uBAAuB;EACvB,wBAAwB,WAAW;EACnC,iBAAiB,IAAI,KAAK;EAC1B,kBAAkB,EAAE;EACpB;EACA,qBAAqB,IAAI,KAAK;EAC9B,qBAAqB,IAAI,KAAK;EAC9B,qCAAqC,IAAI,KAAK;EAC9C,KAAK,wBAAwB,KAAK;EAClC,kBAAkB,IAAI,SAAS;EAC/B,cAAc,EAAE;EAChB,wBAAwB,SAAS;EACjC;EACA,qBAAqB,IAAI,KAAK;EAC9B,uBAAuB,EAAE;EACzB,cAAc,EAAE;EAChB,WAAW,IAAI,IAAI,SAAS,UAAU;EACvC;AAED,QAAO,eAAe,YAAY,KAAK,IAAI,IAAI,IAAI,CAAC;;AAGtD,OAAO,MAAM,+BACX,QACA,UACA,MAA4B,IAAI,KAAK,EACrC,mBACwB;CACxB,MAAM,OAAO,8BAA8B,OAAO;CAClD,MAAM,UAAU,SAAS,MAAM,SAAS;CACxC,MAAM,cAAc,QAAQ,KAAK;AACjC,KAAI,aAAa,SAAS,uBAAuB;AAC/C,SAAO;;CAGT,MAAM,CAAC,cAAc,YAAY;AACjC,KAAI,CAAC,YAAY,MAAM;AACrB,SAAO;;AAGT,QAAO,8BACL,MACA,UACA;EACE,KAAK,WAAW,KAAK;EACrB,OAAO,WAAW,KAAK;EACxB,EACD,KACA,eACD;;AAGH,OAAO,MAAM,oCACX,MACA,UACA,WAAW,OACX,uBACA,mBAC6B;CAC7B,MAAM,UAAU,SAAS,MAAM,SAAS;CACxC,MAAM,WAAW,eAAe,SAAS;EACvC,0BAA0B;EAC1B,sBAAsB,iBAAiB,sBAAsB;EAC9D,CAAC;AAEF,QAAO,mBACL,MACA,UACA,UACA,SACA,UACA,SAAS,mBACT,eACD;;AAGH,OAAO,MAAM,kCACX,MACA,UACA,WAAW,OACX,wBAC6B;CAC7B,MAAM,UAAU,SAAS,MAAM,SAAS;CACxC,MAAM,WAAW,eAAe,SAAS;EACvC,yBAAyB;EACzB,oBAAoB,iBAAiB,oBAAoB;EAC1D,CAAC;CACF,MAAM,cAAc,SAAS,iBAAiB,SAC3C,aAAa,SAAS,YACxB;AAED,QAAO,mBACL,MACA,UACA,UACA,SACA,UACA,YACD","names":[],"sources":["../../../src/utils/collectOxcTemplateDependencies/expressionExtraction.ts"],"version":3,"sourcesContent":["/* eslint-disable no-restricted-syntax,no-continue */\n\nimport type { ExpressionValue } from '@wyw-in-js/shared';\nimport { ValueType } from '@wyw-in-js/shared';\nimport type { Expression, Program } from 'oxc-parser';\n\nimport { applyOxcReplacements } from '../oxc/replacements';\nimport { createOxcLocationLookup } from '../oxc/sourceLocations';\nimport {\n  analyzeProgram,\n  containsTaggedTemplateExpression,\n  createSpanLookup,\n  findReferences,\n  getSourceLocation,\n  isBindingDeclaredWithin,\n  parseOxc,\n  resolveBindingAt,\n} from './scopeAnalysis';\nimport {\n  applyExpressionReplacements,\n  collectIdentifierReferenceReplacements,\n  collectStaticNamespaceMemberReferences,\n  getConstantReplacement,\n  replaceIdentifierReferences,\n} from './expressionReplacements';\nimport {\n  cloneStaticValue,\n  evaluateStatic,\n  isStaticSerializableValue,\n  literalCode,\n} from './staticEvaluator';\nimport type {\n  Binding,\n  ExtractedExpression,\n  ExpressionSpan,\n  ExtractionContext,\n  OxcStaticImportReference,\n  ProgramAnalysis,\n  Replacement,\n  StaticBindings,\n  StaticLocalExpression,\n  TemplateExtractionResult,\n} from './types';\n\nconst allocateExpressionName = (ctx: ExtractionContext): string => {\n  let base = '_exp';\n  let idx = 1;\n  while (ctx.usedNames.has(base)) {\n    idx += 1;\n    base = `_exp${idx}`;\n  }\n\n  ctx.usedNames.add(base);\n  return base;\n};\n\nconst hoistedBindingKey = (binding: Binding): string =>\n  `${binding.scope.start}:${binding.scope.end}:${binding.declaredAt}:${binding.name}`;\n\nconst allocateHoistedBindingName = (\n  originalName: string,\n  ctx: ExtractionContext\n): string => {\n  const sanitized = originalName.replace(/[^A-Za-z0-9_$]/g, '_') || 'hoisted';\n  const base = /^[A-Za-z_$]/.test(sanitized) ? `_${sanitized}` : '_hoisted';\n  let candidate = base;\n  let idx = 2;\n\n  while (ctx.usedNames.has(candidate)) {\n    candidate = `${base}${idx}`;\n    idx += 1;\n  }\n\n  ctx.usedNames.add(candidate);\n  return candidate;\n};\n\nconst getHoistedBindingName = (\n  binding: Binding,\n  ctx: ExtractionContext\n): string => {\n  const key = hoistedBindingKey(binding);\n  const existing = ctx.hoistedBindingNames.get(key);\n  if (existing) {\n    return existing;\n  }\n\n  const next = allocateHoistedBindingName(binding.name, ctx);\n  ctx.hoistedBindingNames.set(key, next);\n  return next;\n};\n\nconst parenthesizeStaticReplacement = (source: string): string => `(${source})`;\n\nconst replaceStaticLocalReferences = (\n  expression: Expression,\n  replacements: Map<string, string>,\n  ctx: ExtractionContext,\n  extraReplacements: Replacement[] = []\n): string => {\n  if (expression.type === 'Identifier' && extraReplacements.length === 0) {\n    return (\n      replacements.get(expression.name) ??\n      ctx.code.slice(expression.start, expression.end)\n    );\n  }\n\n  const parenthesized = new Map<string, string>();\n  replacements.forEach((value, key) => {\n    parenthesized.set(key, parenthesizeStaticReplacement(value));\n  });\n\n  return applyExpressionReplacements(\n    expression,\n    [\n      ...extraReplacements,\n      ...collectIdentifierReferenceReplacements(expression, parenthesized),\n    ],\n    ctx.code\n  );\n};\n\nconst collectStaticLocalExpression = (\n  expression: Expression,\n  ctx: ExtractionContext,\n  stack: string[] = []\n): StaticLocalExpression | null => {\n  const replacements = new Map<string, string>();\n  const importedFrom = new Set<string>();\n  const imports: OxcStaticImportReference[] = [];\n\n  for (const { name, start } of findReferences(\n    expression,\n    ctx.referencesByNode\n  )) {\n    const binding = resolveBindingAt(ctx, name, start);\n    if (!binding) {\n      return null;\n    }\n\n    if (binding.importedFrom) {\n      importedFrom.add(binding.importedFrom);\n      if (binding.imported && binding.imported !== '*') {\n        imports.push({\n          imported: binding.imported,\n          local: binding.name,\n          source: binding.importedFrom,\n        });\n        continue;\n      }\n\n      return null;\n    }\n\n    const replacement = getConstantReplacement(binding, ctx);\n    if (replacement) {\n      replacements.set(name, replacement);\n      continue;\n    }\n\n    if (\n      binding.kind === 'param' ||\n      binding.declarationKind !== 'const' ||\n      !binding.declarator?.init ||\n      binding.declarator.id.type !== 'Identifier'\n    ) {\n      return null;\n    }\n\n    // Processor-managed bindings (const x = css``) carry their value\n    // (the generated className string) via inlineConstants at candidate\n    // evaluation time. Walking the TaggedTemplateExpression here would\n    // pull the processor's tag import (e.g. `css` from '@linaria/core')\n    // into the candidate's static imports, where it fails to resolve.\n    // Leave the identifier as a free reference; the candidate-side env\n    // supplies the className.\n    if (binding.declarator.init.type === 'TaggedTemplateExpression') {\n      continue;\n    }\n\n    const key = hoistedBindingKey(binding);\n    if (stack.includes(key)) {\n      return null;\n    }\n\n    const nested = collectStaticLocalExpression(binding.declarator.init, ctx, [\n      ...stack,\n      key,\n    ]);\n    if (!nested) {\n      return null;\n    }\n\n    replacements.set(name, nested.source);\n    nested.importedFrom.forEach((source) => importedFrom.add(source));\n    imports.push(...nested.imports);\n  }\n\n  return {\n    importedFrom: [...importedFrom],\n    imports,\n    source:\n      replacements.size > 0\n        ? replaceStaticLocalReferences(expression, replacements, ctx)\n        : ctx.code.slice(expression.start, expression.end),\n  };\n};\n\nconst declarationInitCode = (\n  init: Expression,\n  ctx: ExtractionContext\n): string => {\n  const renamedDependencies = new Map<string, string>();\n  findReferences(init, ctx.referencesByNode).forEach(({ name, start }) => {\n    const dependency = resolveBindingAt(ctx, name, start);\n    if (\n      !dependency ||\n      dependency.importedFrom ||\n      dependency.isRoot ||\n      dependency.declarator?.id.type !== 'Identifier'\n    ) {\n      return;\n    }\n\n    renamedDependencies.set(name, getHoistedBindingName(dependency, ctx));\n  });\n\n  return renamedDependencies.size > 0\n    ? replaceIdentifierReferences(init, renamedDependencies, ctx.code)\n    : ctx.code.slice(init.start, init.end);\n};\n\nconst addHoistedCode = (\n  key: string,\n  code: string,\n  ctx: ExtractionContext\n): void => {\n  if (ctx.hoistedDeclarations.has(key)) {\n    return;\n  }\n\n  ctx.hoistedDeclarations.set(key, code);\n  const declarations =\n    ctx.hoistedDeclarationsByInsertionPoint.get(ctx.currentInsertionPoint) ??\n    [];\n  declarations.push(code);\n  ctx.hoistedDeclarationsByInsertionPoint.set(\n    ctx.currentInsertionPoint,\n    declarations\n  );\n};\n\nconst declarationCode = (binding: Binding, ctx: ExtractionContext): string => {\n  const { declarator } = binding;\n  if (!declarator) {\n    return '';\n  }\n\n  const { id } = declarator;\n  if (id.type !== 'Identifier') {\n    const idCode = ctx.code.slice(id.start, id.end);\n    if (!declarator.init) {\n      return `let ${idCode};`;\n    }\n\n    return `let ${idCode} = ${declarationInitCode(declarator.init, ctx)};`;\n  }\n\n  const hoistedName = getHoistedBindingName(binding, ctx);\n  if (!declarator.init) {\n    return `let ${hoistedName};`;\n  }\n\n  return `let ${hoistedName} = ${declarationInitCode(declarator.init, ctx)};`;\n};\n\nconst assertHoistable = (\n  binding: Binding,\n  ctx: ExtractionContext,\n  stack: string[] = []\n): void => {\n  if (!binding.declarator?.init || binding.importedFrom || binding.isRoot) {\n    return;\n  }\n\n  if (stack.includes(binding.name)) {\n    return;\n  }\n\n  const refs = findReferences(binding.declarator.init, ctx.referencesByNode);\n  refs.forEach(({ name, start }) => {\n    const nextBinding = resolveBindingAt(ctx, name, start);\n    if (!nextBinding) {\n      return;\n    }\n\n    if (nextBinding.kind === 'param') {\n      throw new Error(\n        `This identifier cannot be used in the template, because it is a function parameter.`\n      );\n    }\n\n    assertHoistable(nextBinding, ctx, [...stack, binding.name]);\n  });\n};\n\nconst addHoistedDeclaration = (\n  binding: Binding,\n  ctx: ExtractionContext,\n  stack: string[] = []\n): void => {\n  if (\n    !binding.declaration ||\n    !binding.declarator ||\n    binding.importedFrom ||\n    binding.isRoot ||\n    stack.includes(binding.name)\n  ) {\n    return;\n  }\n\n  const hoistSource = binding.declarator.init ?? binding.declarator;\n  findReferences(hoistSource, ctx.referencesByNode).forEach(\n    ({ name, start }) => {\n      const dependency = resolveBindingAt(ctx, name, start);\n      if (dependency) {\n        addHoistedDeclaration(dependency, ctx, [...stack, binding.name]);\n      }\n    }\n  );\n\n  if (!ctx.hoistedDeclarations.has(binding.name)) {\n    addHoistedCode(binding.name, declarationCode(binding, ctx), ctx);\n  }\n};\n\nconst literalExpressionValue = (\n  expression: Expression,\n  ctx: ExtractionContext\n): Omit<ExpressionValue, 'buildCodeFrameError'> | null => {\n  if (expression.type !== 'Literal') {\n    return null;\n  }\n\n  if (\n    expression.value !== null &&\n    typeof expression.value !== 'string' &&\n    typeof expression.value !== 'number' &&\n    typeof expression.value !== 'boolean'\n  ) {\n    return null;\n  }\n\n  let type:\n    | 'BooleanLiteral'\n    | 'NullLiteral'\n    | 'NumericLiteral'\n    | 'StringLiteral';\n  if (expression.value === null) {\n    type = 'NullLiteral';\n  } else if (typeof expression.value === 'string') {\n    type = 'StringLiteral';\n  } else if (typeof expression.value === 'number') {\n    type = 'NumericLiteral';\n  } else {\n    type = 'BooleanLiteral';\n  }\n\n  const loc = getSourceLocation(expression.start, expression.end, ctx);\n  const ex =\n    expression.value === null\n      ? { loc, type }\n      : {\n          loc,\n          type,\n          value: expression.value,\n        };\n\n  return {\n    ex,\n    kind: ValueType.CONST,\n    source: ctx.code.slice(expression.start, expression.end),\n    value: expression.value,\n  } as unknown as Omit<ExpressionValue, 'buildCodeFrameError'>;\n};\n\nconst extractExpression = (\n  expression: Expression,\n  ctx: ExtractionContext,\n  evaluate: boolean\n): ExtractedExpression => {\n  const source = ctx.code.slice(expression.start, expression.end);\n  // Only inline function expressions are function-valued here. A bare\n  // identifier that points to a local function may be a styled runtime\n  // component, so it has to stay as a lazy `_exp()` reference.\n  const isFunction =\n    expression.type === 'FunctionExpression' ||\n    expression.type === 'ArrowFunctionExpression';\n\n  if (evaluate) {\n    const evaluated = evaluateStatic(expression, ctx);\n    const literal = literalCode(evaluated);\n    if (literal) {\n      findReferences(expression, ctx.referencesByNode).forEach(({ name }) =>\n        ctx.dependencyNames.add(name)\n      );\n      return {\n        expressionCode: literal,\n        importedFrom: [],\n        kind: isFunction ? ValueType.FUNCTION : ValueType.LAZY,\n        staticImports: [],\n        staticValue: isStaticSerializableValue(evaluated)\n          ? cloneStaticValue(evaluated)\n          : undefined,\n      };\n    }\n  }\n\n  const identifierReplacements = new Map<string, string>();\n  const importedFrom: string[] = [];\n  const namespaceStatic = collectStaticNamespaceMemberReferences(\n    expression,\n    ctx\n  );\n  const staticIdentifierReplacements = new Map<string, string>();\n  const staticImports: OxcStaticImportReference[] = [\n    ...namespaceStatic.imports,\n  ];\n  let hasNonStaticLocalReference = false;\n  let hasInlinableLocalReference = false;\n\n  findReferences(expression, ctx.referencesByNode).forEach(\n    ({ name, start }) => {\n      const binding = resolveBindingAt(ctx, name, start);\n      if (!binding) {\n        return;\n      }\n\n      if (isFunction && isBindingDeclaredWithin(binding, expression)) {\n        return;\n      }\n\n      ctx.dependencyNames.add(name);\n\n      if (binding.importedFrom) {\n        importedFrom.push(binding.importedFrom);\n        if (binding.imported && binding.imported !== '*') {\n          staticImports.push({\n            imported: binding.imported,\n            local: binding.name,\n            source: binding.importedFrom,\n          });\n        } else if (\n          binding.imported === '*' &&\n          namespaceStatic.coveredReferenceStarts.has(start)\n        ) {\n          // The static candidate source gets a synthetic named import alias,\n          // while the eval fallback keeps the original namespace expression.\n        } else {\n          hasNonStaticLocalReference = true;\n        }\n        return;\n      }\n\n      const replacement = getConstantReplacement(binding, ctx);\n      if (evaluate && replacement) {\n        identifierReplacements.set(name, replacement);\n        return;\n      }\n\n      const init = binding.declarator?.init;\n      // Processor-managed bindings (`const x = css```, or object literals\n      // containing processor tags) carry values that only become known after\n      // processors run. Leave the identifier free in the candidate source so\n      // the resolver can supply it via inlineConstants at evaluation time.\n      const isProcessorManagedLocal =\n        !!evaluate && !!init && containsTaggedTemplateExpression(init);\n      const staticLocalExpression =\n        evaluate && init && !isProcessorManagedLocal\n          ? collectStaticLocalExpression(init, ctx, [\n              hoistedBindingKey(binding),\n            ])\n          : null;\n      if (staticLocalExpression) {\n        staticIdentifierReplacements.set(name, staticLocalExpression.source);\n        importedFrom.push(...staticLocalExpression.importedFrom);\n        staticImports.push(...staticLocalExpression.imports);\n      } else if (isProcessorManagedLocal) {\n        hasInlinableLocalReference = true;\n      } else {\n        hasNonStaticLocalReference = true;\n      }\n\n      assertHoistable(binding, ctx);\n      addHoistedDeclaration(binding, ctx);\n      if (!binding.isRoot && binding.declarator?.id.type === 'Identifier') {\n        identifierReplacements.set(name, getHoistedBindingName(binding, ctx));\n      }\n    }\n  );\n\n  // Merge literal-const inlines (e.g. `const A = 32` -> \"32\") with\n  // local-to-imported substitutions (e.g. `const X = imp.y` -> \"imp.y\").\n  // Both must reach the candidate source so the resolver's evaluator\n  // can fold every Identifier in the expression; env only carries\n  // imported bindings, never same-file locals.\n  const mergedReplacements = new Map(staticIdentifierReplacements);\n  identifierReplacements.forEach((value, key) => {\n    if (!mergedReplacements.has(key)) {\n      mergedReplacements.set(key, value);\n    }\n  });\n\n  let staticExpressionCode: string | undefined;\n  if (mergedReplacements.size > 0) {\n    staticExpressionCode = replaceStaticLocalReferences(\n      expression,\n      mergedReplacements,\n      ctx,\n      namespaceStatic.replacements\n    );\n  } else if (namespaceStatic.replacements.length > 0) {\n    staticExpressionCode = applyExpressionReplacements(\n      expression,\n      namespaceStatic.replacements,\n      ctx.code\n    );\n  }\n\n  return {\n    expressionCode:\n      identifierReplacements.size > 0\n        ? replaceIdentifierReferences(\n            expression,\n            identifierReplacements,\n            ctx.code\n          )\n        : source,\n    importedFrom,\n    kind: isFunction ? ValueType.FUNCTION : ValueType.LAZY,\n    staticExpressionCode,\n    hasInlinableLocalReference:\n      !hasNonStaticLocalReference && hasInlinableLocalReference,\n    staticImports: hasNonStaticLocalReference ? [] : staticImports,\n  };\n};\n\nconst getInsertionPoints = (\n  program: Program,\n  expressions: Expression[]\n): number[] => {\n  if (expressions.length === 0) {\n    return [];\n  }\n\n  if (program.body.length === 0) {\n    return expressions.map(() => 0);\n  }\n\n  const insertionPoints: number[] = [];\n  let ownerIndex = 0;\n\n  expressions.forEach((expression) => {\n    while (\n      ownerIndex < program.body.length - 1 &&\n      program.body[ownerIndex]!.end < expression.start\n    ) {\n      ownerIndex += 1;\n    }\n\n    let owner: Program['body'][number] | undefined = program.body[ownerIndex];\n    if (\n      !owner ||\n      owner.start > expression.start ||\n      owner.end < expression.end\n    ) {\n      owner = program.body.find(\n        (statement) =>\n          statement.start <= expression.start && statement.end >= expression.end\n      );\n    }\n\n    insertionPoints.push(owner?.start ?? 0);\n  });\n\n  return insertionPoints;\n};\n\nconst extractExpressions = (\n  code: string,\n  filename: string,\n  evaluate: boolean,\n  program: Program,\n  analysis: Pick<\n    ProgramAnalysis,\n    'bindingsByName' | 'rootMutationsByBinding' | 'usedNames'\n  >,\n  expressions: Expression[],\n  staticBindings?: StaticBindings\n): TemplateExtractionResult => {\n  if (expressions.length === 0) {\n    return {\n      code,\n      dependencyNames: [],\n      expressionValues: [],\n      staticValueCandidates: [],\n      staticValues: [],\n    };\n  }\n\n  const insertionPoints = getInsertionPoints(program, expressions);\n  const ctx: ExtractionContext = {\n    bindingResolutionCache: new Map(),\n    bindingsByName: analysis.bindingsByName,\n    code,\n    currentInsertionPoint: insertionPoints[0] ?? 0,\n    currentExpressionStart: expressions[0].start,\n    dependencyNames: new Set(),\n    expressionValues: [],\n    filename,\n    hoistedBindingNames: new Map(),\n    hoistedDeclarations: new Map(),\n    hoistedDeclarationsByInsertionPoint: new Map(),\n    loc: createOxcLocationLookup(code),\n    referencesByNode: new WeakMap(),\n    replacements: [],\n    rootMutationsByBinding: analysis.rootMutationsByBinding,\n    staticBindings,\n    staticImportAliases: new Map(),\n    staticValueCandidates: [],\n    staticValues: [],\n    usedNames: new Set(analysis.usedNames),\n  };\n\n  expressions.forEach((expression, index) => {\n    ctx.currentInsertionPoint = insertionPoints[index] ?? 0;\n    ctx.currentExpressionStart = expression.start;\n\n    const literal = literalExpressionValue(expression, ctx);\n    if (literal) {\n      ctx.expressionValues.push(literal);\n      return;\n    }\n\n    const {\n      expressionCode,\n      hasInlinableLocalReference,\n      importedFrom,\n      kind,\n      staticExpressionCode,\n      staticImports,\n      staticValue,\n    } = extractExpression(expression, ctx, evaluate);\n    const expName = allocateExpressionName(ctx);\n\n    addHoistedCode(\n      expName,\n      `const ${expName} = () => (${expressionCode});`,\n      ctx\n    );\n    if (staticValue !== undefined && kind !== ValueType.FUNCTION) {\n      ctx.staticValues.push({\n        name: expName,\n        value: staticValue,\n      });\n    } else if (\n      (staticImports.length > 0 ||\n        hasInlinableLocalReference ||\n        staticExpressionCode !== undefined) &&\n      kind !== ValueType.FUNCTION\n    ) {\n      const uniqueImports = new Map<string, OxcStaticImportReference>();\n      staticImports.forEach((item) => {\n        uniqueImports.set(\n          `${item.local}\\0${item.importLocal ?? ''}\\0${item.source}\\0${\n            item.imported\n          }`,\n          item\n        );\n      });\n      ctx.staticValueCandidates.push({\n        imports: [...uniqueImports.values()],\n        name: expName,\n        source: staticExpressionCode ?? expressionCode,\n      });\n    }\n    ctx.replacements.push({\n      start: expression.start,\n      end: expression.end,\n      value: `${expName}()`,\n    });\n    ctx.expressionValues.push({\n      ex: {\n        loc: getSourceLocation(expression.start, expression.end, ctx),\n        name: expName,\n        type: 'Identifier',\n      },\n      importedFrom,\n      kind,\n      source: ctx.code.slice(expression.start, expression.end),\n    } as unknown as Omit<ExpressionValue, 'buildCodeFrameError'>);\n  });\n\n  ctx.hoistedDeclarationsByInsertionPoint.forEach((declarations, point) => {\n    ctx.replacements.push({\n      start: point,\n      end: point,\n      value: `${declarations.join('\\n')}\\n`,\n    });\n  });\n\n  return {\n    code: applyOxcReplacements(code, ctx.replacements),\n    dependencyNames: [...ctx.dependencyNames],\n    expressionValues: ctx.expressionValues,\n    staticValueCandidates: ctx.staticValueCandidates,\n    staticValues: ctx.staticValues,\n  };\n};\n\nexport const isOxcStaticSerializableValue = (value: unknown): boolean =>\n  isStaticSerializableValue(value);\n\nexport const evaluateOxcStaticExpressionAt = (\n  code: string,\n  filename: string,\n  expressionSpan: ExpressionSpan,\n  env: Map<string, unknown> = new Map(),\n  staticBindings?: StaticBindings\n): unknown | undefined => {\n  const program = parseOxc(code, filename);\n  const analysis = analyzeProgram(program, {\n    collectTargetExpressions: true,\n    expressionSpanLookup: createSpanLookup([expressionSpan]),\n  });\n  const [expression] = analysis.targetExpressions;\n  if (!expression) {\n    return undefined;\n  }\n\n  const ctx: ExtractionContext = {\n    bindingResolutionCache: new Map(),\n    bindingsByName: analysis.bindingsByName,\n    code,\n    currentInsertionPoint: 0,\n    currentExpressionStart: expression.start,\n    dependencyNames: new Set(),\n    expressionValues: [],\n    filename,\n    hoistedBindingNames: new Map(),\n    hoistedDeclarations: new Map(),\n    hoistedDeclarationsByInsertionPoint: new Map(),\n    loc: createOxcLocationLookup(code),\n    referencesByNode: new WeakMap(),\n    replacements: [],\n    rootMutationsByBinding: analysis.rootMutationsByBinding,\n    staticBindings,\n    staticImportAliases: new Map(),\n    staticValueCandidates: [],\n    staticValues: [],\n    usedNames: new Set(analysis.usedNames),\n  };\n\n  return evaluateStatic(expression, ctx, new Map(env));\n};\n\nexport const evaluateOxcStaticExpression = (\n  source: string,\n  filename: string,\n  env: Map<string, unknown> = new Map(),\n  staticBindings?: StaticBindings\n): unknown | undefined => {\n  const code = `const __wyw_static_value = ${source};`;\n  const program = parseOxc(code, filename);\n  const declaration = program.body[0];\n  if (declaration?.type !== 'VariableDeclaration') {\n    return undefined;\n  }\n\n  const [declarator] = declaration.declarations;\n  if (!declarator?.init) {\n    return undefined;\n  }\n\n  return evaluateOxcStaticExpressionAt(\n    code,\n    filename,\n    {\n      end: declarator.init.end,\n      start: declarator.init.start,\n    },\n    env,\n    staticBindings\n  );\n};\n\nexport const collectOxcExpressionDependencies = (\n  code: string,\n  filename: string,\n  evaluate = false,\n  targetExpressionSpans?: ExpressionSpan[],\n  staticBindings?: StaticBindings\n): TemplateExtractionResult => {\n  const program = parseOxc(code, filename);\n  const analysis = analyzeProgram(program, {\n    collectTargetExpressions: true,\n    expressionSpanLookup: createSpanLookup(targetExpressionSpans),\n  });\n\n  return extractExpressions(\n    code,\n    filename,\n    evaluate,\n    program,\n    analysis,\n    analysis.targetExpressions,\n    staticBindings\n  );\n};\n\nexport const collectOxcTemplateDependencies = (\n  code: string,\n  filename: string,\n  evaluate = false,\n  targetTemplateSpans?: ExpressionSpan[]\n): TemplateExtractionResult => {\n  const program = parseOxc(code, filename);\n  const analysis = analyzeProgram(program, {\n    collectTemplateLiterals: true,\n    templateSpanLookup: createSpanLookup(targetTemplateSpans),\n  });\n  const expressions = analysis.templateLiterals.flatMap(\n    (template) => template.expressions\n  );\n\n  return extractExpressions(\n    code,\n    filename,\n    evaluate,\n    program,\n    analysis,\n    expressions\n  );\n};\n"],"file":"expressionExtraction.js"}