@wyw-in-js/transform 1.0.8 → 2.0.0-alpha.0

package/esm/utils/applyOxcProcessors.js

@@ -0,0 +1,1217 @@
+/* eslint-disable no-restricted-syntax */
+import { basename, dirname } from "path";
+import { BaseProcessor, expressionToCode } from "@wyw-in-js/processor-utils";
+import { ValueType } from "@wyw-in-js/shared";
+import { collectOxcProcessorImportsFromProgram } from "./collectOxcExportsAndImports.js";
+import { EventEmitter } from "./EventEmitter.js";
+import { collectOxcExpressionDependencies } from "./collectOxcTemplateDependencies.js";
+import { isNotNull } from "./isNotNull.js";
+import { createOxcAstService, printOxcAstServiceImport } from "./oxcAstService.js";
+import { parseOxcProgramCached } from "./parseOxc.js";
+import { getProcessorForImport } from "./processorLookup.js";
+let didWarnSkipSymbolMismatch = false;
+const GENERATED_HELPER_NAME_RE = /^_exp\d*$/;
+const isNode = (value) => !!value && typeof value === "object" && "type" in value && typeof value.type === "string";
+const getChildren = (node) => {
+	const result = [];
+	const record = node;
+	Object.keys(record).forEach((key) => {
+		if (key === "type" || key === "start" || key === "end" || key === "range") {
+			return;
+		}
+		const value = record[key];
+		if (isNode(value)) {
+			result.push(value);
+			return;
+		}
+		if (Array.isArray(value)) {
+			value.forEach((item) => {
+				if (isNode(item)) {
+					result.push(item);
+				}
+			});
+		}
+	});
+	return result;
+};
+const parseOxc = (code, filename) => {
+	return parseOxcProgramCached(filename, code, "module");
+};
+const visit = (node, enter, parent = null) => {
+	enter(node, parent);
+	getChildren(node).forEach((child) => visit(child, enter, node));
+};
+const applyReplacements = (code, replacements) => {
+	let result = code;
+	replacements.sort((a, b) => b.start - a.start).forEach((replacement) => {
+		result = result.slice(0, replacement.start) + replacement.value + result.slice(replacement.end);
+	});
+	return result;
+};
+const insertAddedImports = (code, program, addedImports) => {
+	if (addedImports.length === 0) {
+		return code;
+	}
+	const uniqueImports = [...new Map(addedImports.map((item) => [`${item.source}\0${item.imported}\0${item.local}`, item])).values()];
+	const importBlock = uniqueImports.map(printOxcAstServiceImport).join("\n");
+	const lastImport = [...program.body].reverse().find((statement) => statement.type === "ImportDeclaration");
+	const hashbangEnd = code.startsWith("#!") ? (() => {
+		const newline = code.indexOf("\n");
+		return newline === -1 ? code.length : newline + 1;
+	})() : 0;
+	const insertionPoint = lastImport?.end ?? hashbangEnd;
+	const prefix = code.slice(0, insertionPoint);
+	const suffix = code.slice(insertionPoint);
+	const leadingBreak = prefix.length > 0 && !prefix.endsWith("\n") ? "\n" : "";
+	const trailingBreak = suffix.length > 0 && !suffix.startsWith("\n") ? "\n" : "";
+	return `${prefix}${leadingBreak}${importBlock}${trailingBreak}${suffix}`;
+};
+const createLocationLookup = (code) => {
+	const lineStarts = [0];
+	for (let idx = 0; idx < code.length; idx += 1) {
+		if (code[idx] === "\n") {
+			lineStarts.push(idx + 1);
+		}
+	}
+	return (offset) => {
+		let low = 0;
+		let high = lineStarts.length - 1;
+		while (low <= high) {
+			const mid = Math.floor((low + high) / 2);
+			const next = lineStarts[mid + 1] ?? Infinity;
+			if (lineStarts[mid] <= offset && offset < next) {
+				return {
+					column: offset - lineStarts[mid],
+					line: mid + 1
+				};
+			}
+			if (offset < lineStarts[mid]) {
+				high = mid - 1;
+			} else {
+				low = mid + 1;
+			}
+		}
+		const lastLine = lineStarts.length - 1;
+		return {
+			column: Math.max(0, offset - lineStarts[lastLine]),
+			line: lastLine + 1
+		};
+	};
+};
+const getSourceLocation = (start, end, loc, filename) => ({
+	end: loc(end),
+	filename: filename ?? undefined,
+	start: loc(start)
+});
+const buildCodeFrameError = (code, location, message) => {
+	const lines = code.split("\n");
+	const startLine = location.start.line;
+	const endLine = location.end.line;
+	const frameStart = Math.max(1, startLine - 2);
+	const frameEnd = Math.min(lines.length, endLine + 2);
+	const lineNoWidth = String(frameEnd).length;
+	const frame = [];
+	for (let lineNo = frameStart; lineNo <= frameEnd; lineNo += 1) {
+		const marker = lineNo === startLine ? ">" : " ";
+		const line = lines[lineNo - 1] ?? "";
+		frame.push(line.length > 0 ? `${marker} ${String(lineNo).padStart(lineNoWidth)} | ${line}` : `${marker} ${String(lineNo).padStart(lineNoWidth)} |`);
+		if (lineNo === startLine) {
+			const pointerLength = startLine === endLine ? Math.max(1, location.end.column - location.start.column) : 1;
+			frame.push(`  ${" ".repeat(lineNoWidth)} | ${" ".repeat(location.start.column)}${"^".repeat(pointerLength)}`);
+		}
+	}
+	const prefix = location.filename ? `${location.filename}: ` : "";
+	return new Error(`${prefix}${message}\n${frame.join("\n")}`);
+};
+const collectUsedNames = (program) => {
+	const names = new Set();
+	visit(program, (node) => {
+		if (node.type === "Identifier") {
+			names.add(node.name);
+		}
+	});
+	return names;
+};
+const isNodeReference = (node, parent) => {
+	if (node.type === "Identifier") {
+		const parentRecord = parent;
+		if (!parentRecord) {
+			return true;
+		}
+		if (parent?.type === "ImportDeclaration" || parent?.type === "ImportSpecifier" || parent?.type === "ImportDefaultSpecifier" || parent?.type === "ImportNamespaceSpecifier") {
+			return false;
+		}
+		if (parent?.type === "MemberExpression" && parentRecord.property === node && !parentRecord.computed) {
+			return false;
+		}
+		if ((parent?.type === "VariableDeclarator" || parent?.type === "FunctionDeclaration" || parent?.type === "ClassDeclaration" || parent?.type === "ClassExpression") && parentRecord.id === node) {
+			return false;
+		}
+		if ((parent?.type === "PropertyDefinition" || parent?.type === "MethodDefinition") && parentRecord.key === node && !parentRecord.computed) {
+			return false;
+		}
+		if (parent?.type === "Property" && parentRecord.key === node && parentRecord.value !== node && !parentRecord.computed) {
+			return false;
+		}
+		return true;
+	}
+	if (node.type === "JSXIdentifier") {
+		const parentRecord = parent;
+		if (parent?.type === "JSXAttribute" && parentRecord?.name === node) {
+			return false;
+		}
+		return true;
+	}
+	return false;
+};
+const collectReferencedNames = (root) => {
+	const names = new Set();
+	const walk = (node, parent = null) => {
+		if (node.type === "ImportDeclaration") {
+			return;
+		}
+		if (isNodeReference(node, parent) && "name" in node && typeof node.name === "string") {
+			names.add(node.name);
+		}
+		getChildren(node).forEach((child) => walk(child, node));
+	};
+	walk(root);
+	return names;
+};
+const collectImportLocalNames = (node) => {
+	if (node.type !== "ImportDeclaration") {
+		return [];
+	}
+	const { specifiers } = node;
+	if (!Array.isArray(specifiers)) {
+		return [];
+	}
+	return specifiers.map((specifier) => {
+		const { local } = specifier;
+		return isNode(local) && "name" in local && typeof local.name === "string" ? local.name : null;
+	}).filter(isNotNull);
+};
+const getImportSpecifierLocalName = (node) => {
+	const { local } = node;
+	return isNode(local) && "name" in local && typeof local.name === "string" ? local.name : null;
+};
+const collectDeclaredNames = (node) => {
+	if (node.type === "Identifier") {
+		return [node.name];
+	}
+	if (node.type === "RestElement") {
+		return collectDeclaredNames(node.argument);
+	}
+	if (node.type === "AssignmentPattern") {
+		return collectDeclaredNames(node.left);
+	}
+	if (node.type === "ObjectPattern") {
+		return node.properties.flatMap((property) => property.type === "RestElement" ? collectDeclaredNames(property.argument) : collectDeclaredNames(property.value));
+	}
+	if (node.type === "ArrayPattern") {
+		return node.elements.flatMap((element) => element ? collectDeclaredNames(element) : []);
+	}
+	if (node.type === "TSParameterProperty") {
+		return collectDeclaredNames(node.parameter);
+	}
+	return [];
+};
+const collectTopLevelBindings = (statement) => {
+	const bindings = new Set();
+	if (statement.type === "ImportDeclaration") {
+		collectImportLocalNames(statement).forEach((name) => bindings.add(name));
+		return bindings;
+	}
+	if (statement.type === "VariableDeclaration") {
+		const { declarations } = statement;
+		if (!Array.isArray(declarations)) {
+			return bindings;
+		}
+		declarations.forEach((declarator) => {
+			const { id } = declarator;
+			if (isNode(id)) {
+				collectDeclaredNames(id).forEach((name) => bindings.add(name));
+			}
+		});
+		return bindings;
+	}
+	if ((statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration" || statement.type === "TSEnumDeclaration") && "id" in statement) {
+		const { id } = statement;
+		if (isNode(id) && id.type === "Identifier") {
+			bindings.add(id.name);
+		}
+		return bindings;
+	}
+	if (statement.type === "ExportNamedDeclaration") {
+		const { declaration } = statement;
+		return isNode(declaration) ? collectTopLevelBindings(declaration) : bindings;
+	}
+	return bindings;
+};
+const collectTopLevelStatementInfos = (program) => program.body.map((statement) => ({
+	bindings: collectTopLevelBindings(statement),
+	node: statement,
+	references: collectReferencedNames(statement)
+}));
+const collectTopLevelBindingsFromStatements = (statements) => new Set(statements.flatMap((statement) => [...statement.bindings]));
+const collectRemovableNamesFromStatements = (statements, initialNames) => {
+	const removable = new Set(initialNames);
+	const bindingToStatement = new Map();
+	statements.forEach((statement) => {
+		statement.bindings.forEach((name) => {
+			bindingToStatement.set(name, statement);
+		});
+	});
+	const queue = [...removable];
+	while (queue.length > 0) {
+		const name = queue.shift();
+		const statement = bindingToStatement.get(name);
+		if (statement) {
+			statement.references.forEach((reference) => {
+				if (bindingToStatement.has(reference) && !removable.has(reference)) {
+					removable.add(reference);
+					queue.push(reference);
+				}
+			});
+		}
+	}
+	return removable;
+};
+const createScopedCleanupScope = (parent) => ({
+	bindings: new Map(),
+	parent
+});
+const resolveScopedBinding = (scope, name) => {
+	let current = scope;
+	while (current) {
+		const bindingId = current.bindings.get(name);
+		if (bindingId) {
+			return bindingId;
+		}
+		current = current.parent;
+	}
+	return null;
+};
+const collectScopedBindingInfos = (program) => {
+	const bindings = new Map();
+	let sequence = 0;
+	const addBinding = (scope, name, kind, declaration) => {
+		const id = `${kind}:${name}:${declaration.start}:${sequence}`;
+		sequence += 1;
+		bindings.set(id, {
+			declaration,
+			dependencies: new Set(),
+			externalReferences: 0,
+			id,
+			incomingFromBindings: new Set(),
+			kind,
+			name
+		});
+		scope.bindings.set(name, id);
+		return id;
+	};
+	const addPatternBindings = (scope, pattern, kind, declaration) => {
+		collectDeclaredNames(pattern).forEach((name) => {
+			addBinding(scope, name, kind, declaration);
+		});
+	};
+	const recordReference = (scope, name, ownerBindingId) => {
+		const targetId = resolveScopedBinding(scope, name);
+		if (!targetId) {
+			return;
+		}
+		const target = bindings.get(targetId);
+		if (!target) {
+			return;
+		}
+		if (ownerBindingId && ownerBindingId !== targetId) {
+			target.incomingFromBindings.add(ownerBindingId);
+			bindings.get(ownerBindingId)?.dependencies.add(targetId);
+			return;
+		}
+		target.externalReferences += 1;
+	};
+	let walk;
+	function walkPatternReferenceSubexpressions(node, scope, ownerBindingId) {
+		if (node.type === "Identifier") {
+			return;
+		}
+		if (node.type === "TSParameterProperty") {
+			walkPatternReferenceSubexpressions(node.parameter, scope, ownerBindingId);
+			return;
+		}
+		if (node.type === "RestElement") {
+			walkPatternReferenceSubexpressions(node.argument, scope, ownerBindingId);
+			return;
+		}
+		if (node.type === "AssignmentPattern") {
+			walkPatternReferenceSubexpressions(node.left, scope, ownerBindingId);
+			walk(node.right, scope, node, ownerBindingId);
+			return;
+		}
+		if (node.type === "ObjectPattern") {
+			node.properties.forEach((property) => {
+				if (property.type === "RestElement") {
+					walkPatternReferenceSubexpressions(property.argument, scope, ownerBindingId);
+					return;
+				}
+				if (property.computed && isNode(property.key)) {
+					walk(property.key, scope, property, ownerBindingId);
+				}
+				walkPatternReferenceSubexpressions(property.value, scope, ownerBindingId);
+			});
+			return;
+		}
+		if (node.type === "ArrayPattern") {
+			node.elements.forEach((element) => {
+				if (element && isNode(element)) {
+					walkPatternReferenceSubexpressions(element, scope, ownerBindingId);
+				}
+			});
+		}
+	}
+	walk = (node, scope, parent = null, ownerBindingId = null) => {
+		if (node.type === "ImportDeclaration") {
+			const { specifiers } = node;
+			if (Array.isArray(specifiers)) {
+				specifiers.forEach((specifier) => {
+					const { local } = specifier;
+					if (isNode(local) && local.type === "Identifier" && typeof local.name === "string") {
+						addBinding(scope, local.name, "import", node);
+					}
+				});
+			}
+			return;
+		}
+		if (node.type === "ExportNamedDeclaration" && node.declaration) {
+			walk(node.declaration, scope, node, ownerBindingId);
+			collectTopLevelBindings(node).forEach((name) => {
+				recordReference(scope, name, ownerBindingId);
+			});
+			return;
+		}
+		if (node.type === "ExportDefaultDeclaration") {
+			const { declaration } = node;
+			if (isNode(declaration)) {
+				walk(declaration, scope, node, ownerBindingId);
+				if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.id) {
+					recordReference(scope, declaration.id.name, ownerBindingId);
+				}
+			}
+			return;
+		}
+		if (node.type === "VariableDeclaration") {
+			const { declarations } = node;
+			if (!Array.isArray(declarations)) {
+				return;
+			}
+			declarations.forEach((declarator) => {
+				const { id } = declarator;
+				if (isNode(id)) {
+					addPatternBindings(scope, id, "variable", node);
+				}
+			});
+			declarations.forEach((declarator) => {
+				const { id } = declarator;
+				const { init } = declarator;
+				if (!isNode(id) || !isNode(init)) {
+					return;
+				}
+				const ownerName = collectDeclaredNames(id)[0] ?? null;
+				const nextOwner = ownerName !== null ? resolveScopedBinding(scope, ownerName) : null;
+				walk(init, scope, declarator, nextOwner);
+			});
+			return;
+		}
+		if (node.type === "FunctionDeclaration" && node.id) {
+			const functionBindingId = addBinding(scope, node.id.name, "function", node);
+			const fnScope = createScopedCleanupScope(scope);
+			node.params.forEach((param) => {
+				addPatternBindings(fnScope, param, "param", param);
+				walkPatternReferenceSubexpressions(param, fnScope, functionBindingId);
+			});
+			if (node.body) {
+				walk(node.body, fnScope, node, functionBindingId);
+			}
+			return;
+		}
+		if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+			const fnScope = createScopedCleanupScope(scope);
+			if (node.type === "FunctionExpression" && node.id) {
+				addBinding(fnScope, node.id.name, "function", node);
+			}
+			node.params.forEach((param) => {
+				addPatternBindings(fnScope, param, "param", param);
+				walkPatternReferenceSubexpressions(param, fnScope, ownerBindingId);
+			});
+			if (node.body) {
+				walk(node.body, fnScope, node, ownerBindingId);
+			}
+			return;
+		}
+		if (node.type === "BlockStatement") {
+			const blockScope = createScopedCleanupScope(scope);
+			getChildren(node).forEach((child) => walk(child, blockScope, node, ownerBindingId));
+			return;
+		}
+		if (isNodeReference(node, parent) && "name" in node && typeof node.name === "string") {
+			recordReference(scope, node.name, ownerBindingId);
+		}
+		getChildren(node).forEach((child) => walk(child, scope, node, ownerBindingId));
+	};
+	walk(program, createScopedCleanupScope(null));
+	return bindings;
+};
+const collectScopedRemovableBindingIds = (bindings, initialNames) => {
+	const removable = new Set();
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const binding of bindings.values()) {
+			if (!removable.has(binding.id) && binding.kind !== "import" && binding.kind !== "param" && binding.externalReferences === 0) {
+				const seededByName = initialNames.has(binding.name) || GENERATED_HELPER_NAME_RE.test(binding.name) && binding.incomingFromBindings.size === 0;
+				const allIncomingRemovable = binding.incomingFromBindings.size > 0 && [...binding.incomingFromBindings].every((sourceId) => removable.has(sourceId));
+				if (seededByName && binding.incomingFromBindings.size === 0 || allIncomingRemovable) {
+					removable.add(binding.id);
+					changed = true;
+				}
+			}
+		}
+	}
+	return removable;
+};
+function expandImportRemovalRange(code, start, end) {
+	let removalStart = start;
+	while (removalStart > 0 && (code[removalStart - 1] === " " || code[removalStart - 1] === "	")) {
+		removalStart -= 1;
+	}
+	let removalEnd = end;
+	if (code[removalEnd] === ";") {
+		removalEnd += 1;
+	}
+	while (removalEnd < code.length && (code[removalEnd] === " " || code[removalEnd] === "	")) {
+		removalEnd += 1;
+	}
+	if (code[removalEnd] === "\r" && code[removalEnd + 1] === "\n") {
+		removalEnd += 2;
+	} else if (code[removalEnd] === "\n") {
+		removalEnd += 1;
+	}
+	return {
+		end: removalEnd,
+		start: removalStart,
+		value: ""
+	};
+}
+const collectUnusedScopedDeclarationRemovals = (code, bindings, initialRemovableNames) => {
+	const removableBindingIds = collectScopedRemovableBindingIds(bindings, initialRemovableNames);
+	const removals = new Map();
+	bindings.forEach((binding) => {
+		if (!removableBindingIds.has(binding.id) || binding.kind === "import" || binding.kind === "param" || binding.externalReferences > 0 || [...binding.incomingFromBindings].some((sourceId) => !removableBindingIds.has(sourceId))) {
+			return;
+		}
+		if (binding.kind === "function" && binding.declaration.type === "FunctionDeclaration") {
+			const range = expandImportRemovalRange(code, binding.declaration.start, binding.declaration.end);
+			removals.set(`${range.start}:${range.end}`, range);
+			return;
+		}
+		if (binding.declaration.type !== "VariableDeclaration") {
+			return;
+		}
+		const { declarations } = binding.declaration;
+		if (!Array.isArray(declarations) || declarations.length !== 1) {
+			return;
+		}
+		const range = expandImportRemovalRange(code, binding.declaration.start, binding.declaration.end);
+		removals.set(`${range.start}:${range.end}`, range);
+	});
+	return [...removals.values()];
+};
+const expandImportSpecifierRemovalRange = (code, start, end) => {
+	let removalStart = start;
+	let removalEnd = end;
+	let whitespaceStart = removalStart;
+	while (whitespaceStart > 0 && (code[whitespaceStart - 1] === " " || code[whitespaceStart - 1] === "	")) {
+		whitespaceStart -= 1;
+	}
+	if (code[whitespaceStart - 1] !== "{") {
+		removalStart = whitespaceStart;
+	}
+	while (removalEnd < code.length && (code[removalEnd] === " " || code[removalEnd] === "	")) {
+		removalEnd += 1;
+	}
+	if (code[removalEnd] === ",") {
+		removalEnd += 1;
+		while (removalEnd < code.length && (code[removalEnd] === " " || code[removalEnd] === "	")) {
+			removalEnd += 1;
+		}
+	} else {
+		while (removalStart > 0 && (code[removalStart - 1] === " " || code[removalStart - 1] === "	")) {
+			removalStart -= 1;
+		}
+		if (code[removalStart - 1] === ",") {
+			removalStart -= 1;
+			while (removalStart > 0 && (code[removalStart - 1] === " " || code[removalStart - 1] === "	")) {
+				removalStart -= 1;
+			}
+		}
+	}
+	return {
+		end: removalEnd,
+		start: removalStart,
+		value: ""
+	};
+};
+const mergeEmptyRemovalRanges = (removals) => {
+	if (removals.length <= 1) {
+		return removals;
+	}
+	const sorted = [...removals].sort((a, b) => a.start - b.start);
+	const merged = [];
+	sorted.forEach((removal) => {
+		const previous = merged[merged.length - 1];
+		if (previous && previous.value === "" && removal.value === "" && removal.start <= previous.end) {
+			previous.end = Math.max(previous.end, removal.end);
+			return;
+		}
+		merged.push({ ...removal });
+	});
+	return merged;
+};
+const collectUnusedImportRemovals = (code, program, referencedNames, removableNames, preserveSideEffectImportLocals) => {
+	const removals = [];
+	program.body.forEach((statement) => {
+		if (statement.type !== "ImportDeclaration") {
+			return;
+		}
+		const localNames = collectImportLocalNames(statement);
+		const removableLocalNames = localNames.filter((localName) => removableNames.has(localName));
+		if (removableLocalNames.length > 0 && removableLocalNames.length === localNames.length && removableLocalNames.every((localName) => !referencedNames.has(localName))) {
+			if (removableLocalNames.some((localName) => preserveSideEffectImportLocals.has(localName))) {
+				removals.push({
+					end: statement.end,
+					start: statement.start,
+					value: `import ${code.slice(statement.source.start, statement.source.end)};`
+				});
+				return;
+			}
+			removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+			return;
+		}
+		const { specifiers } = statement;
+		if (!Array.isArray(specifiers) || specifiers.length <= 1) {
+			return;
+		}
+		specifiers.forEach((specifier) => {
+			if (!isNode(specifier)) {
+				return;
+			}
+			const localName = getImportSpecifierLocalName(specifier);
+			if (localName && removableNames.has(localName) && !referencedNames.has(localName)) {
+				removals.push(expandImportSpecifierRemovalRange(code, specifier.start, specifier.end));
+			}
+		});
+	});
+	return removals;
+};
+const collectUnusedTopLevelDeclarationRemovals = (code, program, referencedNames, removableNames) => {
+	const removals = [];
+	program.body.forEach((statement) => {
+		if (statement.type !== "VariableDeclaration") {
+			return;
+		}
+		const localNames = [...collectTopLevelBindings(statement)];
+		if (localNames.length > 0 && localNames.every((localName) => removableNames.has(localName)) && localNames.every((localName) => !referencedNames.has(localName))) {
+			removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+		}
+	});
+	return removals;
+};
+const collectUnusedGeneratedHelperDeclarationRemovals = (code, program, referencedNames) => {
+	const removals = [];
+	program.body.forEach((statement) => {
+		if (statement.type !== "VariableDeclaration") {
+			return;
+		}
+		const localNames = [...collectTopLevelBindings(statement)];
+		if (localNames.length > 0 && localNames.every((localName) => GENERATED_HELPER_NAME_RE.test(localName)) && localNames.every((localName) => !referencedNames.has(localName))) {
+			removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+		}
+	});
+	return removals;
+};
+const collectTopLevelExpressionStatementRemovals = (code, statements, topLevelBindings, removableExpressionRefs) => {
+	const removals = [];
+	statements.forEach((statement) => {
+		if (statement.node.type !== "ExpressionStatement") {
+			return;
+		}
+		const { expression } = statement.node;
+		const isPureExpression = expression.type === "Identifier" || expression.type === "Literal" || expression.type === "ObjectExpression" || expression.type === "ArrayExpression" || expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression" || expression.type === "TemplateLiteral" && expression.expressions.length === 0;
+		if (!isPureExpression) {
+			return;
+		}
+		const localReferences = [...statement.references].filter((name) => topLevelBindings.has(name));
+		if (localReferences.length > 0 && localReferences.every((name) => removableExpressionRefs.has(name))) {
+			removals.push(expandImportRemovalRange(code, statement.node.start, statement.node.end));
+		}
+	});
+	return removals;
+};
+const collectEmptyTopLevelBlockRemovals = (code, program) => {
+	const removals = [];
+	program.body.forEach((statement) => {
+		if (statement.type !== "BlockStatement" || statement.body.length > 0) {
+			return;
+		}
+		removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+	});
+	return removals;
+};
+const removeUnusedAfterReplacement = (code, filename, initialRemovableNames, removableExpressionRefs, preserveSideEffectImportLocals) => {
+	let current = code;
+	const cumulativeRemovableNames = new Set(initialRemovableNames);
+	const applyIfParsable = (next) => {
+		try {
+			parseOxc(next, filename);
+			return next;
+		} catch {
+			return current;
+		}
+	};
+	for (let idx = 0; idx < 5; idx += 1) {
+		const previous = current;
+		const program = parseOxc(current, filename);
+		const statements = collectTopLevelStatementInfos(program);
+		const removableNames = collectRemovableNamesFromStatements(statements, cumulativeRemovableNames);
+		removableNames.forEach((name) => cumulativeRemovableNames.add(name));
+		const referencedNames = collectReferencedNames(program);
+		const topLevelBindings = collectTopLevelBindingsFromStatements(statements);
+		const scopedBindings = collectScopedBindingInfos(program);
+		const removals = mergeEmptyRemovalRanges([
+			...collectUnusedScopedDeclarationRemovals(current, scopedBindings, cumulativeRemovableNames),
+			...collectUnusedTopLevelDeclarationRemovals(current, program, referencedNames, cumulativeRemovableNames),
+			...collectUnusedGeneratedHelperDeclarationRemovals(current, program, referencedNames),
+			...collectUnusedImportRemovals(current, program, referencedNames, cumulativeRemovableNames, preserveSideEffectImportLocals),
+			...collectTopLevelExpressionStatementRemovals(current, statements, topLevelBindings, removableExpressionRefs),
+			...collectEmptyTopLevelBlockRemovals(current, program)
+		]);
+		current = removals.length > 0 ? applyIfParsable(applyReplacements(current, removals)) : current;
+		if (current === previous) {
+			return current;
+		}
+	}
+	return current;
+};
+const getMemberName = (node) => {
+	if (node.computed) {
+		return node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
+	}
+	return node.property.type === "Identifier" ? node.property.name : null;
+};
+const unwrapQualifiedExpression = (node) => {
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression" || node.type === "TSTypeAssertion" || node.type === "ParenthesizedExpression") {
+		return unwrapQualifiedExpression(node.expression);
+	}
+	if (node.type === "SequenceExpression") {
+		const sequence = node;
+		return unwrapQualifiedExpression(sequence.expressions[sequence.expressions.length - 1] ?? node);
+	}
+	return node;
+};
+const getRootIdentifier = (node) => {
+	const expression = unwrapQualifiedExpression(node);
+	if (expression.type === "Identifier") {
+		return expression;
+	}
+	if (expression.type === "MemberExpression") {
+		return getRootIdentifier(expression.object);
+	}
+	if (expression.type === "CallExpression") {
+		return getRootIdentifier(expression.callee);
+	}
+	return null;
+};
+const getQualifiedName = (node) => {
+	const expression = unwrapQualifiedExpression(node);
+	if (expression.type === "Identifier") {
+		return expression.name;
+	}
+	if (expression.type === "MemberExpression") {
+		const object = getQualifiedName(expression.object);
+		const member = getMemberName(expression);
+		return object && member ? `${object}.${member}` : null;
+	}
+	if (expression.type === "CallExpression") {
+		return getQualifiedName(expression.callee);
+	}
+	return null;
+};
+const resolveDefinedProcessor = (callee, definedProcessors) => {
+	const qualified = getQualifiedName(callee);
+	if (qualified) {
+		const definedProcessor = definedProcessors.get(qualified);
+		if (definedProcessor) {
+			return {
+				collapseQualifiedCallee: qualified.includes("."),
+				definedProcessor
+			};
+		}
+	}
+	const root = getRootIdentifier(callee);
+	if (!root) {
+		return null;
+	}
+	const definedProcessor = definedProcessors.get(root.name);
+	return definedProcessor ? {
+		collapseQualifiedCallee: false,
+		definedProcessor
+	} : null;
+};
+const isCallTagOfTaggedTemplate = (node, parent) => parent?.type === "TaggedTemplateExpression" && parent.tag === node;
+const expandReplacementTarget = (target, ancestors) => {
+	let current = target;
+	for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+		const ancestor = ancestors[idx];
+		if (ancestor.type === "SequenceExpression" && ancestor.expressions[ancestor.expressions.length - 1] === current) {
+			current = ancestor;
+		} else if (ancestor.type === "ParenthesizedExpression" && ancestor.expression === current) {
+			current = ancestor;
+		} else {
+			break;
+		}
+	}
+	return current;
+};
+const collectProcessorUsages = (program, definedProcessors) => {
+	const usages = [];
+	const walk = (node, ancestors, parent = null) => {
+		if (node.type === "TaggedTemplateExpression") {
+			const callee = node.tag;
+			const resolvedProcessor = resolveDefinedProcessor(callee, definedProcessors);
+			if (resolvedProcessor) {
+				usages.push({
+					ancestors,
+					callee,
+					collapseQualifiedCallee: resolvedProcessor.collapseQualifiedCallee,
+					definedProcessor: resolvedProcessor.definedProcessor,
+					kind: "template",
+					replacementTarget: expandReplacementTarget(node, ancestors),
+					target: node
+				});
+			}
+		} else if (node.type === "CallExpression" && !isCallTagOfTaggedTemplate(node, parent)) {
+			const { callee } = node;
+			const resolvedProcessor = resolveDefinedProcessor(callee, definedProcessors);
+			if (resolvedProcessor) {
+				usages.push({
+					ancestors,
+					callee,
+					collapseQualifiedCallee: resolvedProcessor.collapseQualifiedCallee,
+					definedProcessor: resolvedProcessor.definedProcessor,
+					kind: "call",
+					replacementTarget: expandReplacementTarget(node, ancestors),
+					target: node
+				});
+			}
+		}
+		getChildren(node).forEach((child) => walk(child, [...ancestors, node], node));
+	};
+	walk(program, []);
+	return usages.sort((a, b) => a.target.start - b.target.start);
+};
+const expressionSpan = (expression) => ({
+	end: expression.end,
+	start: expression.start
+});
+const collectCallArgumentSpans = (node) => {
+	const expression = unwrapQualifiedExpression(node);
+	if (expression.type === "CallExpression") {
+		const call = expression;
+		const calleeSpans = collectCallArgumentSpans(call.callee);
+		const argumentSpans = call.arguments.flatMap((arg) => arg.type === "SpreadElement" ? [] : [expressionSpan(arg)]);
+		return [...calleeSpans, ...argumentSpans];
+	}
+	if (expression.type === "MemberExpression") {
+		return collectCallArgumentSpans(expression.object);
+	}
+	return [];
+};
+const collectUsageExpressionSpans = (usage) => {
+	const calleeSpans = collectCallArgumentSpans(usage.callee);
+	if (usage.kind === "template") {
+		return [...calleeSpans, ...usage.target.quasi.expressions.map((expression) => expressionSpan(expression))];
+	}
+	return [...calleeSpans, ...usage.target.arguments.flatMap((arg) => arg.type === "SpreadElement" ? [] : [expressionSpan(arg)])];
+};
+const literalExpressionValue = (expression, code, source, location) => {
+	if (expression.type !== "Literal") {
+		return null;
+	}
+	if (expression.value === null || typeof expression.value === "string" || typeof expression.value === "number" || typeof expression.value === "boolean") {
+		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 ex = expression.value === null ? {
+			loc: location,
+			type
+		} : {
+			loc: location,
+			type,
+			value: expression.value
+		};
+		return {
+			buildCodeFrameError: (message) => buildCodeFrameError(code, location, message),
+			ex,
+			kind: ValueType.CONST,
+			source,
+			value: expression.value
+		};
+	}
+	return null;
+};
+const expressionValue = (expression, code, loc, filename) => {
+	const source = code.slice(expression.start, expression.end);
+	const location = getSourceLocation(expression.start, expression.end, loc, filename);
+	const literal = literalExpressionValue(expression, code, source, location);
+	if (literal) {
+		return literal;
+	}
+	const helperCallName = expression.type === "CallExpression" && expression.arguments.length === 0 && expression.callee.type === "Identifier" && GENERATED_HELPER_NAME_RE.test(expression.callee.name) ? expression.callee.name : null;
+	let ex;
+	if (expression.type === "Identifier") {
+		ex = {
+			loc: location,
+			name: expression.name,
+			type: "Identifier"
+		};
+	} else if (helperCallName) {
+		ex = {
+			loc: location,
+			name: helperCallName,
+			type: "Identifier"
+		};
+	} else {
+		ex = {
+			loc: location,
+			name: code.slice(expression.start, expression.end),
+			type: "Identifier"
+		};
+	}
+	return {
+		buildCodeFrameError: (message) => buildCodeFrameError(code, location, message),
+		ex,
+		kind: expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression" ? ValueType.FUNCTION : ValueType.LAZY,
+		source
+	};
+};
+const withCurrentExpressionLocation = (value, expression, loc, filename) => {
+	const location = getSourceLocation(expression.start, expression.end, loc, filename);
+	if (value.kind === ValueType.CONST) {
+		return {
+			...value,
+			ex: {
+				...value.ex,
+				loc: location
+			}
+		};
+	}
+	if (value.kind === ValueType.FUNCTION) {
+		return {
+			...value,
+			ex: {
+				...value.ex,
+				loc: location
+			}
+		};
+	}
+	return {
+		...value,
+		ex: {
+			...value.ex,
+			loc: location
+		}
+	};
+};
+const shiftExpressionValue = (expressionValues, expression, code, loc, filename) => expressionValues.length > 0 ? withCurrentExpressionLocation(expressionValues.shift(), expression, loc, filename) : expressionValue(expression, code, loc, filename);
+const zipTemplate = (template, code, loc, filename, expressionValues) => {
+	const parts = template.quasi.quasis.flatMap((quasi, idx) => {
+		const expression = template.quasi.expressions[idx];
+		const templateElement = {
+			...quasi,
+			loc: getSourceLocation(quasi.start, quasi.end, loc, filename)
+		};
+		return [templateElement, expression ? shiftExpressionValue(expressionValues, expression, code, loc, filename) : null].filter(isNotNull);
+	});
+	return ["template", parts];
+};
+const buildCalleeParams = (node, code, loc, filename, expressionValues, collapseQualifiedCallee = false) => {
+	const expression = unwrapQualifiedExpression(node);
+	if (collapseQualifiedCallee && (expression.type === "Identifier" || expression.type === "MemberExpression")) {
+		return [["callee", expression]];
+	}
+	if (expression.type === "Identifier") {
+		return [["callee", {
+			name: expression.name,
+			type: "Identifier"
+		}]];
+	}
+	if (expression.type === "MemberExpression") {
+		const params = buildCalleeParams(expression.object, code, loc, filename, expressionValues, collapseQualifiedCallee);
+		const member = getMemberName(expression);
+		return params && member ? [...params, ["member", member]] : null;
+	}
+	if (expression.type === "CallExpression") {
+		const call = expression;
+		const params = buildCalleeParams(call.callee, code, loc, filename, expressionValues, collapseQualifiedCallee);
+		if (!params) {
+			return null;
+		}
+		const callValues = call.arguments.filter((arg) => arg.type !== "SpreadElement").map((arg) => shiftExpressionValue(expressionValues, arg, code, loc, filename));
+		return [...params, ["call", ...callValues]];
+	}
+	return null;
+};
+const buildParams = (usage, code, loc, filename, expressionValues, collapseQualifiedCallee) => {
+	const params = buildCalleeParams(usage.callee, code, loc, filename, expressionValues, collapseQualifiedCallee);
+	if (!params) {
+		return null;
+	}
+	if (usage.kind === "template") {
+		return [...params, zipTemplate(usage.target, code, loc, filename, expressionValues)];
+	}
+	const callValues = usage.target.arguments.filter((arg) => arg.type !== "SpreadElement").map((arg) => shiftExpressionValue(expressionValues, arg, code, loc, filename));
+	return [...params, ["call", ...callValues]];
+};
+const getPropertyKeyName = (property, code) => {
+	const { key } = property;
+	if (!isNode(key)) {
+		return null;
+	}
+	if (key.type === "Identifier") {
+		return key.name;
+	}
+	if (key.type === "Literal") {
+		return String(key.value);
+	}
+	return typeof key.start === "number" && typeof key.end === "number" ? code.slice(key.start, key.end) : null;
+};
+const getDisplayName = (ancestors, idx, code, filename) => {
+	const owner = [...ancestors].reverse().find((node) => {
+		return node.type === "Property" || node.type === "JSXOpeningElement" || node.type === "VariableDeclarator";
+	});
+	if (owner?.type === "Property") {
+		const keyName = getPropertyKeyName(owner, code);
+		if (keyName) {
+			return keyName;
+		}
+	} else if (owner?.type === "JSXOpeningElement") {
+		const { name } = owner;
+		if (isNode(name) && name.type === "JSXIdentifier") {
+			return name.name;
+		}
+	} else if (owner?.type === "VariableDeclarator") {
+		const { id } = owner;
+		if (isNode(id) && id.type === "Identifier") {
+			return id.name;
+		}
+	}
+	let displayName = basename(filename ?? "unknown").replace(/\.[a-z\d]+$/, "");
+	if (filename && /^index\.[a-z\d]+$/.test(basename(filename))) {
+		displayName = basename(dirname(filename));
+	}
+	if (!displayName) {
+		throw new Error("Couldn't determine a name for the component. Ensure that it's either:\n" + "- Assigned to a variable\n" + "- Is an object property\n" + "- Is a prop in a JSX element\n");
+	}
+	return `${displayName}${idx}`;
+};
+const getTagOwner = (ancestors) => {
+	const owner = [...ancestors].reverse().find((node) => node.type === "Property" || node.type === "JSXOpeningElement" || node.type === "VariableDeclarator");
+	return owner ?? null;
+};
+const isTagReferenced = (program, ancestors) => {
+	const owner = getTagOwner(ancestors);
+	if (owner?.type !== "VariableDeclarator") {
+		return true;
+	}
+	const { id } = owner;
+	if (!isNode(id) || id.type !== "Identifier") {
+		return true;
+	}
+	if (ancestors.some((node) => node.type === "ExportNamedDeclaration")) {
+		return true;
+	}
+	let referenced = false;
+	visit(program, (node, parent) => {
+		const referenceName = node.type === "Identifier" || node.type === "JSXIdentifier" ? node.name : null;
+		if (referenced || referenceName !== id.name || node.type === "Identifier" && node.start === id.start && node.end === id.end) {
+			return;
+		}
+		referenced = isNodeReference(node, parent);
+	});
+	return referenced;
+};
+const isReplacementPure = (replacement) => replacement.type === "CallExpression";
+const createProcessor = (definedProcessor, params, target, replacementTarget, ancestors, fileContext, options, code, loc, idx, isReferenced, usedNames, replacements) => {
+	const [Processor, tagSource] = definedProcessor;
+	const astService = createOxcAstService(usedNames);
+	const replacer = (replacement, isPure) => {
+		const next = typeof replacement === "function" ? replacement(target) : replacement;
+		const replacementCode = expressionToCode(next);
+		replacements.push({
+			start: replacementTarget.start,
+			end: replacementTarget.end,
+			value: isPure && isReplacementPure(next) ? `/*#__PURE__*/${replacementCode}` : replacementCode
+		});
+	};
+	try {
+		let displayName;
+		try {
+			displayName = getDisplayName(ancestors, idx, code, fileContext.filename);
+		} catch (error) {
+			if (error instanceof Error && error.message.startsWith("Couldn't determine a name for the component")) {
+				let displayNameNode = target;
+				if (target.type === "TaggedTemplateExpression") {
+					displayNameNode = target.tag;
+				} else if (target.type === "CallExpression") {
+					displayNameNode = target.callee;
+				}
+				const pointerNode = displayNameNode.type === "MemberExpression" ? getRootIdentifier(displayNameNode) ?? displayNameNode : displayNameNode;
+				throw buildCodeFrameError(code, getSourceLocation(pointerNode.start, pointerNode.end, loc, fileContext.filename), error.message);
+			}
+			throw error;
+		}
+		return {
+			astService,
+			processor: new Processor(params, tagSource, astService, getSourceLocation(target.start, target.end, loc, fileContext.filename), replacer, displayName, isReferenced, idx, options, fileContext)
+		};
+	} catch (e) {
+		if (e === BaseProcessor.SKIP) {
+			return null;
+		}
+		if (typeof e === "symbol" && e.description === BaseProcessor.SKIP.description) {
+			if (!didWarnSkipSymbolMismatch) {
+				didWarnSkipSymbolMismatch = true;
+				// eslint-disable-next-line no-console
+				console.warn([
+					"[wyw-in-js] Processor threw Symbol('skip') that does not match BaseProcessor.SKIP identity.",
+					"This usually means duplicate copies of @wyw-in-js/processor-utils (or the processor) are bundled/installed.",
+					"Consider deduping dependencies to avoid subtle issues (instanceof checks, sentinels, etc)."
+				].join("\n"));
+			}
+			return null;
+		}
+		throw e;
+	}
+};
+export const applyOxcProcessors = (code, fileContext, options, callback, cleanupUnused = false) => {
+	const filename = fileContext.filename ?? "unknown.js";
+	const eventEmitter = options.eventEmitter ?? EventEmitter.dummy;
+	let workingCode = code;
+	let program = parseOxc(workingCode, filename);
+	const definedProcessors = new Map();
+	const removableImportLocals = new Set();
+	const removableExpressionRefs = new Set();
+	eventEmitter.perf("transform:preeval:processTemplate:imports", () => {
+		const imports = eventEmitter.perf("transform:preeval:processTemplate:imports:analysis", () => collectOxcProcessorImportsFromProgram(program, workingCode));
+		eventEmitter.perf("transform:preeval:processTemplate:imports:lookup", () => {
+			imports.forEach((item) => {
+				const localName = item.local.name ?? item.local.code;
+				if (item.imported === "side-effect" || !localName) {
+					return;
+				}
+				const [processor, tagSource] = getProcessorForImport({
+					imported: item.imported,
+					source: item.source
+				}, filename, options);
+				if (processor) {
+					definedProcessors.set(localName, [processor, tagSource]);
+					removableImportLocals.add(localName);
+					const rootLocalName = localName.split(".")[0];
+					if (rootLocalName) {
+						removableImportLocals.add(rootLocalName);
+					}
+				}
+			});
+		});
+	});
+	if (definedProcessors.size === 0) {
+		return {
+			code: workingCode,
+			processors: [],
+			staticValueCandidates: [],
+			staticValues: []
+		};
+	}
+	let processorUsages = eventEmitter.perf("transform:preeval:processTemplate:usages", () => collectProcessorUsages(program, definedProcessors));
+	if (processorUsages.length === 0) {
+		return {
+			code: workingCode,
+			processors: [],
+			staticValueCandidates: [],
+			staticValues: []
+		};
+	}
+	const targetExpressionSpans = processorUsages.flatMap(collectUsageExpressionSpans);
+	const extracted = targetExpressionSpans.length > 0 ? eventEmitter.perf("transform:preeval:processTemplate:deps", () => collectOxcExpressionDependencies(workingCode, filename, options.evaluate, targetExpressionSpans)) : {
+		code: workingCode,
+		dependencyNames: [],
+		expressionValues: [],
+		staticValueCandidates: [],
+		staticValues: []
+	};
+	if (extracted.code !== workingCode) {
+		workingCode = extracted.code;
+		program = eventEmitter.perf("transform:preeval:processTemplate:reparse", () => parseOxc(workingCode, filename));
+		processorUsages = eventEmitter.perf("transform:preeval:processTemplate:usages", () => collectProcessorUsages(program, definedProcessors));
+	}
+	const templateExpressionValues = extracted.expressionValues.map((value) => ({
+		...value,
+		buildCodeFrameError: (message) => buildCodeFrameError(code, value.ex.loc, message)
+	}));
+	const loc = createLocationLookup(workingCode);
+	const usedNames = eventEmitter.perf("transform:preeval:processTemplate:usedNames", () => collectUsedNames(program));
+	const addedImports = [];
+	const replacements = [];
+	const processors = [];
+	extracted.dependencyNames.forEach((name) => removableImportLocals.add(name));
+	eventEmitter.perf("transform:preeval:processTemplate:processors", () => {
+		processorUsages.forEach((usage, idx) => {
+			const params = buildParams(usage, workingCode, loc, filename, templateExpressionValues, usage.collapseQualifiedCallee);
+			if (!params) {
+				return;
+			}
+			const created = createProcessor(usage.definedProcessor, params, usage.target, usage.replacementTarget, usage.ancestors, fileContext, options, workingCode, loc, idx, isTagReferenced(program, usage.ancestors), usedNames, replacements);
+			if (!created) {
+				return;
+			}
+			const { astService, processor } = created;
+			const owner = getTagOwner(usage.ancestors);
+			if (owner?.type === "VariableDeclarator") {
+				const { id } = owner;
+				if (isNode(id) && id.type === "Identifier") {
+					removableExpressionRefs.add(id.name);
+				}
+			}
+			processors.push(processor);
+			callback(processor);
+			addedImports.push(...astService.getAddedImports());
+		});
+	});
+	const replacedCode = applyReplacements(workingCode, replacements);
+	const codeWithAddedImports = insertAddedImports(replacedCode, program, addedImports);
+	return {
+		code: cleanupUnused ? eventEmitter.perf("transform:preeval:processTemplate:cleanup", () => removeUnusedAfterReplacement(codeWithAddedImports, filename, removableImportLocals, new Set([...removableExpressionRefs, ...extracted.dependencyNames]), options.preserveSideEffectImportLocals ?? new Set())) : codeWithAddedImports,
+		processors,
+		staticValueCandidates: extracted.staticValueCandidates,
+		staticValues: extracted.staticValues
+	};
+};
+//# sourceMappingURL=applyOxcProcessors.js.map