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

package/esm/utils/oxcPreevalTransforms.js

@@ -0,0 +1,1065 @@
+import { collectOxcExportsAndImports } from "./collectOxcExportsAndImports.js";
+import { EventEmitter } from "./EventEmitter.js";
+import { parseOxcProgramCached } from "./parseOxc.js";
+const ssrCheckFields = new Set([
+	"document",
+	"location",
+	"navigator",
+	"sessionStorage",
+	"localStorage",
+	"window"
+]);
+const forbiddenGlobals = new Set([
+	...ssrCheckFields,
+	"$RefreshReg$",
+	"$RefreshSig$",
+	"XMLHttpRequest",
+	"clearImmediate",
+	"clearInterval",
+	"clearTimeout",
+	"fetch",
+	"navigator",
+	"setImmediate",
+	"setInterval",
+	"setTimeout"
+]);
+const alwaysForbiddenIdentifiers = new Set(["$RefreshReg$", "$RefreshSig$"]);
+const promiseCallbackMethods = new Set([
+	"then",
+	"catch",
+	"finally"
+]);
+const jsxRuntimeSources = new Set(["react/jsx-runtime", "react/jsx-dev-runtime"]);
+const defaultPlaceholder = "...";
+const defaultReactComponentTypes = [
+	"ExoticComponent",
+	"FC",
+	"ForwardRefExoticComponent",
+	"FunctionComponent",
+	"LazyExoticComponent",
+	"MemoExoticComponent",
+	"NamedExoticComponent"
+];
+const defaultReactHocs = ["forwardRef", "memo"];
+const generatedProcessorHelperNameRe = /^_exp\d*$/;
+const requireCallRe = /\brequire\s*\(/;
+const windowTokenRe = /\bwindow\b/;
+const removableOwnerTypes = new Set([
+	"DoWhileStatement",
+	"ExpressionStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"FunctionDeclaration",
+	"IfStatement",
+	"PropertyDefinition",
+	"ReturnStatement",
+	"VariableDeclaration",
+	"WhileStatement"
+]);
+const importMetaEnvRe = /\bimport\s*\.\s*meta\s*\.\s*env\b/;
+const createScope = (parent, key) => ({
+	bindings: new Map(),
+	key,
+	names: new Set(),
+	parent
+});
+const createsScope = (node) => node.type === "Program" || node.type === "BlockStatement" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+const hasBinding = (scope, name) => {
+	let current = scope;
+	while (current) {
+		if (current.names.has(name)) {
+			return true;
+		}
+		current = current.parent;
+	}
+	return false;
+};
+const getBindingKey = (scope, name) => {
+	let current = scope;
+	while (current) {
+		if (current.names.has(name)) {
+			return `${current.key}\0${name}`;
+		}
+		current = current.parent;
+	}
+	return null;
+};
+const getStaticBinding = (scope, name) => {
+	let current = scope;
+	while (current) {
+		if (current.bindings.has(name)) {
+			return current.bindings.get(name);
+		}
+		current = current.parent;
+	}
+	return undefined;
+};
+const isFileLikeRequireSpecifier = (value) => value.startsWith(".") || value.startsWith("/") || value.startsWith("file:");
+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, "unambiguous");
+};
+const unwrapExpression = (node) => {
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression" || node.type === "TSTypeAssertion" || node.type === "ParenthesizedExpression") {
+		return unwrapExpression(node.expression);
+	}
+	return node;
+};
+const getMemberPropertyName = (node) => {
+	if (node.type !== "MemberExpression") {
+		return null;
+	}
+	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 isStringLikeExpression = (node) => {
+	const expression = unwrapExpression(node);
+	if (expression.type === "Literal" && typeof expression.value === "string") {
+		return true;
+	}
+	if (expression.type === "TemplateLiteral") {
+		return true;
+	}
+	if (expression.type === "BinaryExpression" && expression.operator === "+") {
+		return isStringLikeExpression(expression.left) || isStringLikeExpression(expression.right);
+	}
+	if (expression.type === "CallExpression" && expression.callee.type === "MemberExpression" && getMemberPropertyName(expression.callee) === "concat") {
+		return isStringLikeExpression(expression.callee.object);
+	}
+	return false;
+};
+const templateLiteralToConcat = (code, node) => {
+	if (node.type !== "TemplateLiteral" || node.expressions.length === 0) {
+		return code.slice(node.start, node.end);
+	}
+	const parts = [];
+	node.quasis.forEach((quasi, index) => {
+		const cooked = quasi.value.cooked ?? quasi.value.raw;
+		if (cooked !== "") {
+			parts.push(JSON.stringify(cooked));
+		}
+		const expression = node.expressions[index];
+		if (expression) {
+			parts.push(code.slice(expression.start, expression.end));
+		}
+	});
+	return parts.length > 0 ? parts.join(" + ") : "\"\"";
+};
+const dynamicImportArgumentCode = (code, node) => {
+	if (node.type === "TemplateLiteral") {
+		return templateLiteralToConcat(code, node);
+	}
+	return code.slice(node.start, node.end);
+};
+const evaluateStaticValue = (node, scope, seen = new Set()) => {
+	const expression = unwrapExpression(node);
+	if (expression.type === "Literal") {
+		return expression.value;
+	}
+	if (expression.type === "TemplateLiteral") {
+		let result = "";
+		for (let idx = 0; idx < expression.quasis.length; idx += 1) {
+			result += expression.quasis[idx]?.value.cooked ?? "";
+			const nextExpression = expression.expressions[idx];
+			if (!nextExpression) {
+				continue;
+			}
+			const value = evaluateStaticValue(nextExpression, scope, seen);
+			if (value === undefined || typeof value !== "string" && typeof value !== "number") {
+				return undefined;
+			}
+			result += String(value);
+		}
+		return result;
+	}
+	if (expression.type === "Identifier") {
+		if (seen.has(expression.name)) {
+			return undefined;
+		}
+		const binding = getStaticBinding(scope, expression.name);
+		if (!binding) {
+			return undefined;
+		}
+		return evaluateStaticValue(binding, scope, new Set([...seen, expression.name]));
+	}
+	if (expression.type === "BinaryExpression" && expression.operator === "+") {
+		const left = evaluateStaticValue(expression.left, scope, seen);
+		const right = evaluateStaticValue(expression.right, scope, seen);
+		if (left === undefined || right === undefined) {
+			return undefined;
+		}
+		if (typeof left === "number" && typeof right === "number") {
+			return left + right;
+		}
+		if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number")) {
+			return `${left}${right}`;
+		}
+	}
+	if (expression.type === "CallExpression" && expression.callee.type === "MemberExpression") {
+		const objectValue = evaluateStaticValue(expression.callee.object, scope, seen);
+		const propertyName = getMemberPropertyName(expression.callee);
+		if (!propertyName) {
+			return undefined;
+		}
+		if (typeof objectValue === "string") {
+			if (propertyName === "toLowerCase" && expression.arguments.length === 0) {
+				return objectValue.toLowerCase();
+			}
+			if (propertyName === "toUpperCase" && expression.arguments.length === 0) {
+				return objectValue.toUpperCase();
+			}
+			if (propertyName === "trim" && expression.arguments.length === 0) {
+				return objectValue.trim();
+			}
+			if (propertyName === "concat") {
+				const args = expression.arguments.map((argument) => argument.type === "SpreadElement" ? undefined : evaluateStaticValue(argument, scope, seen));
+				if (args.some((value) => value === undefined) || args.some((value) => typeof value !== "string" && typeof value !== "number")) {
+					return undefined;
+				}
+				return objectValue.concat(...args.map((value) => String(value)));
+			}
+		}
+	}
+	return undefined;
+};
+const isLiteralRequireArg = (node) => {
+	const expression = unwrapExpression(node);
+	if (expression.type === "Literal" && typeof expression.value === "string") {
+		return true;
+	}
+	if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) {
+		return true;
+	}
+	return false;
+};
+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 isIdentifierNamed = (value, name) => isNode(value) && value.type === "Identifier" && value.name === name;
+const isImportMeta = (node) => {
+	if (!isNode(node) || node.type !== "MetaProperty") {
+		return false;
+	}
+	const metaProperty = node;
+	return isIdentifierNamed(metaProperty.meta, "import") && isIdentifierNamed(metaProperty.property, "meta");
+};
+const isImportMetaEnv = (node) => {
+	if (node.type !== "MemberExpression") {
+		return false;
+	}
+	if (node.computed || !isIdentifierNamed(node.property, "env")) {
+		return false;
+	}
+	return isImportMeta(node.object);
+};
+const collectBindingNames = (node) => {
+	if (node.type === "Identifier") {
+		return [node.name];
+	}
+	if (node.type === "RestElement") {
+		return collectBindingNames(node.argument);
+	}
+	if (node.type === "AssignmentPattern") {
+		return collectBindingNames(node.left);
+	}
+	if (node.type === "ObjectPattern") {
+		return node.properties.flatMap((property) => property.type === "RestElement" ? collectBindingNames(property.argument) : collectBindingNames(property.value));
+	}
+	if (node.type === "ArrayPattern") {
+		return node.elements.flatMap((element) => element ? collectBindingNames(element) : []);
+	}
+	if (node.type === "TSParameterProperty") {
+		return collectBindingNames(node.parameter);
+	}
+	return [];
+};
+const predeclareScopeNames = (node, scope) => {
+	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+		if (node.type !== "ArrowFunctionExpression" && node.id) {
+			scope.names.add(node.id.name);
+		}
+		node.params.forEach((param) => {
+			collectBindingNames(param).forEach((name) => {
+				scope.names.add(name);
+			});
+		});
+	}
+	const visitScopeDescendants = (child) => {
+		if (child.type === "VariableDeclarator") {
+			collectBindingNames(child.id).forEach((name) => {
+				scope.names.add(name);
+			});
+		} else if (child.type === "FunctionDeclaration" && child.id) {
+			scope.names.add(child.id.name);
+		} else if (child.type === "ClassDeclaration" && child.id) {
+			scope.names.add(child.id.name);
+		} else if (child.type === "ImportDefaultSpecifier" || child.type === "ImportNamespaceSpecifier" || child.type === "ImportSpecifier") {
+			scope.names.add(child.local.name);
+		}
+		if (createsScope(child)) {
+			return;
+		}
+		getChildren(child).forEach(visitScopeDescendants);
+	};
+	getChildren(node).forEach(visitScopeDescendants);
+};
+const declareBindings = (node, scope) => {
+	if (node.type === "VariableDeclarator") {
+		const names = collectBindingNames(node.id);
+		names.forEach((name) => {
+			scope.names.add(name);
+			scope.bindings.set(name, null);
+		});
+		if (node.id.type === "Identifier" && node.init) {
+			scope.bindings.set(node.id.name, node.init);
+		}
+		return;
+	}
+	if (node.type === "FunctionDeclaration" && node.id) {
+		scope.names.add(node.id.name);
+		scope.bindings.set(node.id.name, null);
+	}
+	if (node.type === "ClassDeclaration" && node.id) {
+		scope.names.add(node.id.name);
+		scope.bindings.set(node.id.name, null);
+		return;
+	}
+	if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier" || node.type === "ImportSpecifier") {
+		scope.names.add(node.local.name);
+		scope.bindings.set(node.local.name, null);
+		return;
+	}
+	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+		node.params.forEach((param) => {
+			collectBindingNames(param).forEach((name) => {
+				scope.names.add(name);
+				scope.bindings.set(name, null);
+			});
+		});
+	}
+};
+const visit = (node, scope, enter, parent = null, ancestors = []) => {
+	let currentScope = scope;
+	if (createsScope(node)) {
+		currentScope = createScope(scope, `${node.type}:${node.start}:${node.end}`);
+		predeclareScopeNames(node, currentScope);
+	}
+	declareBindings(node, currentScope);
+	enter(node, currentScope, parent, ancestors);
+	getChildren(node).forEach((child) => visit(child, currentScope, enter, node, [...ancestors, node]));
+};
+export const replaceImportMetaEnvWithOxc = (code, filename) => {
+	if (!importMetaEnvRe.test(code)) {
+		return code;
+	}
+	const replacements = [];
+	visit(parseOxc(code, filename), createScope(null, "root"), (node) => {
+		if (!isImportMetaEnv(node)) {
+			return;
+		}
+		replacements.push({
+			end: node.end,
+			start: node.start,
+			value: "__wyw_import_meta_env"
+		});
+	});
+	return applyReplacements(code, replacements);
+};
+function collectDynamicImportAndRequireFallbackReplacements(code, filename, options) {
+	const eventEmitter = options.eventEmitter ?? EventEmitter.dummy;
+	const dynamicImportCandidates = [];
+	const requireFallbackCandidates = [];
+	eventEmitter.perf("transform:preeval:dynamicImportRequireFallback:scan", () => {
+		visit(parseOxc(code, filename), createScope(null, "root"), (node, scope) => {
+			if (options.rewriteDynamicImports && node.type === "ImportExpression") {
+				dynamicImportCandidates.push(node);
+			}
+			if (!options.addRequireFallback || node.type !== "CallExpression") {
+				return;
+			}
+			const call = node;
+			if (call.callee.type !== "Identifier" || call.callee.name !== "require" || hasBinding(scope, "require") || call.arguments.length !== 1) {
+				return;
+			}
+			const [firstArg] = call.arguments;
+			if (!firstArg || firstArg.type === "SpreadElement" || isLiteralRequireArg(firstArg)) {
+				return;
+			}
+			requireFallbackCandidates.push({
+				call,
+				scope
+			});
+		});
+	});
+	const replacements = [];
+	eventEmitter.perf("transform:preeval:dynamicImport", () => {
+		dynamicImportCandidates.forEach((importExpression) => {
+			const argument = importExpression.source;
+			const nextArgument = isStringLikeExpression(argument) ? unwrapExpression(argument) : argument;
+			replacements.push({
+				end: importExpression.end,
+				start: importExpression.start,
+				value: `__wyw_dynamic_import(${dynamicImportArgumentCode(code, nextArgument)})`
+			});
+		});
+	});
+	eventEmitter.perf("transform:preeval:requireFallback", () => {
+		requireFallbackCandidates.forEach(({ call, scope }) => {
+			const [firstArg] = call.arguments;
+			if (!firstArg || firstArg.type === "SpreadElement") {
+				return;
+			}
+			const staticValue = evaluateStaticValue(firstArg, scope);
+			if (typeof staticValue === "string" && isFileLikeRequireSpecifier(staticValue)) {
+				replacements.push({
+					end: firstArg.end,
+					start: firstArg.start,
+					value: JSON.stringify(staticValue)
+				});
+				return;
+			}
+			replacements.push({
+				end: firstArg.end,
+				start: firstArg.end,
+				value: ", true"
+			});
+		});
+	});
+	return replacements;
+}
+export const rewriteDynamicImportsWithOxc = (code, filename) => {
+	const replacements = collectDynamicImportAndRequireFallbackReplacements(code, filename, {
+		addRequireFallback: false,
+		rewriteDynamicImports: true
+	});
+	return applyReplacements(code, replacements);
+};
+export const addRequireFallbackWithOxc = (code, filename) => {
+	const replacements = collectDynamicImportAndRequireFallbackReplacements(code, filename, {
+		addRequireFallback: true,
+		rewriteDynamicImports: false
+	});
+	return applyReplacements(code, replacements);
+};
+export const rewriteDynamicImportsAndAddRequireFallbackWithOxc = (code, filename, options) => {
+	const replacements = collectDynamicImportAndRequireFallbackReplacements(code, filename, options);
+	return applyReplacements(code, replacements);
+};
+const isBindingPosition = (node, parent) => {
+	if (!parent) {
+		return false;
+	}
+	if (parent.type === "VariableDeclarator" && parent.id === node) {
+		return true;
+	}
+	if ((parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && parent.id === node) {
+		return true;
+	}
+	if (parent.type === "ImportSpecifier" && (parent.local === node || parent.imported === node)) {
+		return true;
+	}
+	if ((parent.type === "ImportDefaultSpecifier" || parent.type === "ImportNamespaceSpecifier") && parent.local === node) {
+		return true;
+	}
+	if (parent.type === "ExportSpecifier" && (parent.local === node || parent.exported === node)) {
+		return true;
+	}
+	return false;
+};
+const isPropertyOnlyIdentifier = (node, parent) => {
+	if (!parent) {
+		return false;
+	}
+	if (parent.type === "MemberExpression" && !parent.computed && parent.property === node) {
+		return true;
+	}
+	if ((parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") && !parent.computed && parent.key === node) {
+		return true;
+	}
+	return false;
+};
+const isTypeContext = (ancestors) => ancestors.some((ancestor) => ancestor.type.startsWith("TS") || ancestor.type.startsWith("JSDoc"));
+const isInsideTypeof = (ancestors) => ancestors.some((ancestor) => ancestor.type === "UnaryExpression" && ancestor.operator === "typeof");
+const isInsideImportDeclaration = (ancestors) => ancestors.some((ancestor) => ancestor.type === "ImportDeclaration");
+function findLastAncestor(ancestors, predicate) {
+	for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+		const ancestor = ancestors[idx];
+		if (predicate(ancestor)) {
+			return ancestor;
+		}
+	}
+	return null;
+}
+const findRemovableOwner = (node, ancestors) => {
+	let owner = node;
+	let ownerAncestorIndex = -1;
+	if (!removableOwnerTypes.has(node.type)) {
+		for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+			const ancestor = ancestors[idx];
+			if (removableOwnerTypes.has(ancestor.type)) {
+				owner = ancestor;
+				ownerAncestorIndex = idx;
+				break;
+			}
+		}
+	}
+	const parent = ownerAncestorIndex > 0 ? ancestors[ownerAncestorIndex - 1] : null;
+	if (parent?.type === "ExportNamedDeclaration" && "declaration" in parent && parent.declaration === owner) {
+		return parent;
+	}
+	return owner;
+};
+const collectReExportedLocalNames = (program) => {
+	const names = new Set();
+	for (const stmt of program.body) {
+		if (stmt.type !== "ExportNamedDeclaration" || stmt.declaration || stmt.source) {
+			continue;
+		}
+		for (const spec of stmt.specifiers) {
+			if (spec.type === "ExportSpecifier" && spec.local.type === "Identifier") {
+				names.add(spec.local.name);
+			}
+		}
+	}
+	return names;
+};
+// When an offending identifier sits inside the value of a top-level export,
+// removing the surrounding declaration would strip the export binding too.
+// ESM linker then fails on consumers' `import { name } from '...'` because the
+// named export no longer exists. To keep the binding alive, replace just the
+// value (declarator init or default-export expression) with `undefined`.
+const findExportedBindingProtection = (node, ancestors, reExportedLocalNames) => {
+	for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+		const ancestor = ancestors[idx];
+		if (ancestor.type === "ExportDefaultDeclaration") {
+			const decl = ancestor.declaration;
+			if (decl && decl !== node && "start" in decl && "end" in decl) {
+				return {
+					start: decl.start,
+					end: decl.end,
+					value: "undefined"
+				};
+			}
+			return null;
+		}
+		if (ancestor.type !== "VariableDeclarator") {
+			continue;
+		}
+		if (ancestor.id.type !== "Identifier" || !ancestor.init || ancestor.init === node) {
+			return null;
+		}
+		const varDecl = ancestors[idx - 1];
+		const wrapper = ancestors[idx - 2] ?? null;
+		if (varDecl?.type !== "VariableDeclaration") {
+			return null;
+		}
+		const isDirectExport = wrapper?.type === "ExportNamedDeclaration" && wrapper.declaration === varDecl;
+		const isTopLevelDeclaration = wrapper === null || wrapper?.type === "Program";
+		const isReExported = isTopLevelDeclaration && reExportedLocalNames.has(ancestor.id.name);
+		if (!isDirectExport && !isReExported) {
+			return null;
+		}
+		return {
+			start: ancestor.init.start,
+			end: ancestor.init.end,
+			value: "undefined"
+		};
+	}
+	return null;
+};
+const findPromiseCallbackOwner = (ancestors) => {
+	for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+		const ancestor = ancestors[idx];
+		if (ancestor.type === "NewExpression" && ancestor.callee.type === "Identifier" && ancestor.callee.name === "Promise") {
+			return ancestor;
+		}
+		if (ancestor.type === "CallExpression" && ancestor.callee.type === "MemberExpression" && promiseCallbackMethods.has(getMemberPropertyName(ancestor.callee) ?? "")) {
+			return ancestor;
+		}
+	}
+	return null;
+};
+const containsForbiddenIdentifier = (node) => {
+	if (node.type === "Identifier" && alwaysForbiddenIdentifiers.has(node.name)) {
+		return true;
+	}
+	return getChildren(node).some(containsForbiddenIdentifier);
+};
+const collectWindowScopedNames = (program) => {
+	const windowScopedNames = new Set();
+	visit(program, createScope(null, "root"), (node, scope) => {
+		if (node.type !== "MemberExpression" || node.object.type !== "Identifier" || node.object.name !== "window" || hasBinding(scope, "window")) {
+			return;
+		}
+		const propertyName = getMemberPropertyName(node);
+		if (propertyName) {
+			windowScopedNames.add(propertyName);
+		}
+	});
+	return windowScopedNames;
+};
+const containsForbiddenReference = (node, scope, windowScopedNames, derivedForbiddenBindings = new Set()) => {
+	let found = false;
+	visit(node, scope, (child, childScope, parent, ancestors) => {
+		if (found || child.type !== "Identifier" || isTypeContext(ancestors) || isInsideTypeof(ancestors) || isPropertyOnlyIdentifier(child, parent) || isBindingPosition(child, parent)) {
+			return;
+		}
+		const bindingKey = getBindingKey(childScope, child.name);
+		if (alwaysForbiddenIdentifiers.has(child.name) || forbiddenGlobals.has(child.name) && !hasBinding(childScope, child.name) || windowScopedNames.has(child.name) && !hasBinding(childScope, child.name) || bindingKey !== null && derivedForbiddenBindings.has(bindingKey)) {
+			found = true;
+		}
+	});
+	return found;
+};
+const nameFromModuleExport = (node) => {
+	if (node.type === "Identifier") {
+		return node.name;
+	}
+	if (node.type === "Literal" && typeof node.value === "string") {
+		return node.value;
+	}
+	return null;
+};
+const collectImportBindings = (code, filename, program) => {
+	const bindings = new Map();
+	const addBinding = (binding) => {
+		bindings.set(`${binding.local}\0${binding.source}\0${binding.imported}`, binding);
+	};
+	program.body.forEach((statement) => {
+		if (statement.type !== "ImportDeclaration") {
+			return;
+		}
+		const source = statement.source.value;
+		statement.specifiers.forEach((specifier) => {
+			if (specifier.type === "ImportDefaultSpecifier") {
+				addBinding({
+					imported: "default",
+					local: specifier.local.name,
+					source
+				});
+				return;
+			}
+			if (specifier.type === "ImportNamespaceSpecifier") {
+				addBinding({
+					imported: "*",
+					local: specifier.local.name,
+					source
+				});
+				return;
+			}
+			const imported = nameFromModuleExport(specifier.imported);
+			if (!imported) {
+				return;
+			}
+			addBinding({
+				imported,
+				local: specifier.local.name,
+				source
+			});
+		});
+	});
+	if (!requireCallRe.test(code)) {
+		return [...bindings.values()];
+	}
+	collectOxcExportsAndImports(code, filename).imports.forEach((item) => {
+		if (item.imported === "side-effect") {
+			return;
+		}
+		addBinding({
+			imported: item.imported,
+			local: item.local.code,
+			source: item.source
+		});
+		if (item.local.name && item.local.name !== item.local.code) {
+			addBinding({
+				imported: item.imported,
+				local: item.local.name,
+				source: item.source
+			});
+		}
+	});
+	return [...bindings.values()];
+};
+const getImportBinding = (imports, local) => imports.find((item) => item.local === local);
+function unwrapSequenceCallee(node) {
+	if (node.type === "SequenceExpression" && node.expressions.length === 2 && node.expressions[0]?.type === "Literal" && node.expressions[0].value === 0) {
+		return node.expressions[1];
+	}
+	return node;
+}
+const getExpressionImportKey = (node) => {
+	const expression = unwrapSequenceCallee(node);
+	if (expression.type === "Identifier") {
+		return expression.name;
+	}
+	if (expression.type !== "MemberExpression") {
+		return null;
+	}
+	if (expression.object.type !== "Identifier") {
+		return null;
+	}
+	const propertyName = getMemberPropertyName(expression);
+	return propertyName ? `${expression.object.name}.${propertyName}` : null;
+};
+const isHookOrCreateElement = (name) => name === "createElement" || /use[A-Z]/.test(name);
+const getInnermostCallee = (call) => {
+	let callee = unwrapSequenceCallee(call.callee);
+	while (callee.type === "CallExpression") {
+		callee = unwrapSequenceCallee(callee.callee);
+	}
+	return callee;
+};
+const getImportForExpression = (node, imports) => {
+	const expression = unwrapSequenceCallee(node);
+	const directMatchKey = getExpressionImportKey(expression);
+	if (directMatchKey) {
+		const directMatch = getImportBinding(imports, directMatchKey);
+		if (directMatch) {
+			return [directMatch.source, directMatch.imported];
+		}
+	}
+	if (expression.type === "Identifier") {
+		const matched = getImportBinding(imports, expression.name);
+		return matched ? [matched.source, matched.imported] : undefined;
+	}
+	if (expression.type !== "MemberExpression") {
+		return undefined;
+	}
+	if (expression.object.type !== "Identifier") {
+		return undefined;
+	}
+	const propertyName = getMemberPropertyName(expression);
+	if (!propertyName) {
+		return undefined;
+	}
+	const objectImport = getImportBinding(imports, expression.object.name);
+	if (!objectImport) {
+		return undefined;
+	}
+	if (objectImport.imported === "default" || objectImport.imported === "*" || objectImport.source === "react") {
+		return [objectImport.source, propertyName];
+	}
+	return undefined;
+};
+const isReactRuntimeCall = (call, imports) => {
+	const callee = unwrapSequenceCallee(call.callee);
+	const matched = getImportForExpression(callee, imports);
+	if (!matched) {
+		return false;
+	}
+	const [source, imported] = matched;
+	if (jsxRuntimeSources.has(source)) {
+		return true;
+	}
+	return source === "react" && isHookOrCreateElement(imported);
+};
+const isHocCall = (call, hocs, imports) => {
+	const matched = getImportForExpression(getInnermostCallee(call), imports);
+	return !!matched && hocs[matched[0]]?.includes(matched[1]);
+};
+const isInsideHocCall = (ancestors, hocs, imports) => ancestors.some((ancestor) => ancestor.type === "CallExpression" && isHocCall(ancestor, hocs, imports));
+const getComponentTypes = (options) => {
+	const componentTypes = { ...options?.componentTypes ?? { react: [defaultPlaceholder] } };
+	const reactTypes = componentTypes.react;
+	if (Array.isArray(reactTypes) && reactTypes.includes(defaultPlaceholder)) {
+		const idx = reactTypes.indexOf(defaultPlaceholder);
+		componentTypes.react = [...reactTypes];
+		componentTypes.react.splice(idx, 1, ...defaultReactComponentTypes);
+	}
+	return componentTypes;
+};
+const getHocs = (options) => {
+	const hocs = { ...options?.hocs ?? {} };
+	const reactHocs = new Set([...defaultReactHocs, ...hocs.react ?? []]);
+	hocs.react = [...reactHocs];
+	return hocs;
+};
+const getTypeImport = (node, imports) => {
+	if (node.type === "Identifier") {
+		const matched = getImportBinding(imports, node.name);
+		return matched ? [matched.source, matched.imported] : undefined;
+	}
+	if (node.type !== "TSQualifiedName") {
+		return undefined;
+	}
+	if (node.left.type !== "Identifier") {
+		return undefined;
+	}
+	const matched = getImportBinding(imports, node.left.name);
+	return matched ? [matched.source, node.right.name] : undefined;
+};
+const isComponentTypeMatch = (id, componentTypes, imports) => {
+	if (id.type !== "Identifier") {
+		return false;
+	}
+	const annotation = id.typeAnnotation;
+	if (!annotation || annotation.type !== "TSTypeAnnotation" || annotation.typeAnnotation.type !== "TSTypeReference") {
+		return false;
+	}
+	const matched = getTypeImport(annotation.typeAnnotation.typeName, imports);
+	return !!matched && componentTypes[matched[0]]?.includes(matched[1]);
+};
+const getClassName = (node) => node.type === "ClassDeclaration" && node.id ? node.id.name : null;
+const isFunctionLikeNode = (node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+const isImmediatelyInvokedFunction = (fnNode, ancestors, fnIndex) => {
+	// Walk past any ParenthesizedExpression / SequenceExpression wrappers that
+	// sit between the function and its enclosing CallExpression. oxc-parser
+	// preserves ParenthesizedExpression nodes, so `(() => {...})()` shows up
+	// as CallExpression -> ParenthesizedExpression -> ArrowFunctionExpression.
+	let child = fnNode;
+	for (let idx = fnIndex - 1; idx >= 0; idx -= 1) {
+		const ancestor = ancestors[idx];
+		if (ancestor.type === "ParenthesizedExpression" && "expression" in ancestor && ancestor.expression === child) {
+			child = ancestor;
+			continue;
+		}
+		if (ancestor.type === "SequenceExpression" && Array.isArray(ancestor.expressions) && ancestor.expressions[ancestor.expressions.length - 1] === child) {
+			child = ancestor;
+			continue;
+		}
+		return ancestor.type === "CallExpression" && ancestor.callee === child;
+	}
+	return false;
+};
+// A reference is "deferred" when it lives inside a function body that is
+// not immediately invoked. Module preeval reads exports without calling
+// them, so deferred references never run and must not be sanitized — that
+// would silently drop the binding (or remove the entire export) and break
+// importers that expect the function to be callable.
+const isInDeferredFunctionScope = (ancestors) => {
+	for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+		const ancestor = ancestors[idx];
+		if (!isFunctionLikeNode(ancestor)) {
+			continue;
+		}
+		if (!isImmediatelyInvokedFunction(ancestor, ancestors, idx)) {
+			return true;
+		}
+	}
+	return false;
+};
+const findFunctionReplacement = (ancestors) => {
+	const renderMethod = findLastAncestor(ancestors, (ancestor) => ancestor.type === "MethodDefinition" && ancestor.key.type === "Identifier" && ancestor.key.name === "render");
+	if (renderMethod) {
+		const classDecl = findLastAncestor(ancestors, (ancestor) => ancestor.type === "ClassDeclaration");
+		const className = classDecl ? getClassName(classDecl) : null;
+		if (classDecl && className) {
+			return {
+				start: classDecl.start,
+				end: classDecl.end,
+				value: `function ${className}() { return null; }`
+			};
+		}
+	}
+	const functionNode = findLastAncestor(ancestors, isFunctionLikeNode);
+	if (!functionNode) {
+		return null;
+	}
+	if (functionNode.type === "ArrowFunctionExpression") {
+		return {
+			start: functionNode.start,
+			end: functionNode.end,
+			value: `${functionNode.async ? "async " : ""}() => { return null; }`
+		};
+	}
+	if (functionNode.type === "FunctionDeclaration") {
+		return {
+			start: functionNode.start,
+			end: functionNode.end,
+			value: `${functionNode.async ? "async " : ""}function ${functionNode.id?.name ?? ""}() { return null; }`
+		};
+	}
+	return {
+		start: functionNode.body.start,
+		end: functionNode.body.end,
+		value: "{ return null; }"
+	};
+};
+const normalizeReplacements = (replacements) => {
+	const sorted = [...replacements].sort((a, b) => a.start === b.start ? b.end - a.end : a.start - b.start);
+	const result = [];
+	sorted.forEach((replacement) => {
+		const last = result[result.length - 1];
+		if (last && replacement.start >= last.start && replacement.end <= last.end) {
+			return;
+		}
+		result.push(replacement);
+	});
+	return result;
+};
+export const removeDangerousCodeWithOxc = (code, filename, options) => {
+	const replacements = [];
+	const derivedForbiddenBindings = new Set();
+	const program = parseOxc(code, filename);
+	const imports = collectImportBindings(code, filename, program);
+	const componentTypes = getComponentTypes(options);
+	const hocs = getHocs(options);
+	const hasHocs = Object.keys(hocs).length > 0;
+	const windowScopedNames = windowTokenRe.test(code) ? collectWindowScopedNames(program) : new Set();
+	const reExportedLocalNames = collectReExportedLocalNames(program);
+	const derivedBindingDiscovery = { found: true };
+	while (derivedBindingDiscovery.found) {
+		derivedBindingDiscovery.found = false;
+		visit(program, createScope(null, "root"), (node, scope) => {
+			if (node.type !== "VariableDeclarator" || node.id.type !== "Identifier" || !node.init) {
+				return;
+			}
+			const bindingKey = getBindingKey(scope, node.id.name);
+			if (!bindingKey || derivedForbiddenBindings.has(bindingKey)) {
+				return;
+			}
+			if (containsForbiddenIdentifier(node.init) || containsForbiddenReference(node.init, scope, windowScopedNames, derivedForbiddenBindings)) {
+				derivedForbiddenBindings.add(bindingKey);
+				derivedBindingDiscovery.found = true;
+			}
+		});
+	}
+	visit(program, createScope(null, "root"), (node, scope, parent, ancestors) => {
+		if (node.type === "JSXElement" || node.type === "JSXFragment") {
+			replacements.push(findFunctionReplacement(ancestors) ?? {
+				start: node.start,
+				end: node.end,
+				value: "null"
+			});
+			return;
+		}
+		if (node.type === "CallExpression") {
+			if (isReactRuntimeCall(node, imports)) {
+				const replacement = findFunctionReplacement(ancestors);
+				if (replacement) {
+					replacements.push(replacement);
+				}
+				return;
+			}
+			if (hasHocs && isHocCall(node, hocs, imports)) {
+				replacements.push({
+					start: node.start,
+					end: node.end,
+					value: "() => null"
+				});
+				return;
+			}
+		}
+		if (node.type === "VariableDeclarator" && node.id.type === "Identifier" && node.init && isComponentTypeMatch(node.id, componentTypes, imports)) {
+			replacements.push({
+				start: node.init.start,
+				end: node.init.end,
+				value: "() => null"
+			});
+			return;
+		}
+		if (node.type === "UnaryExpression" && node.operator === "typeof" && node.argument.type === "Identifier" && ssrCheckFields.has(node.argument.name) && !hasBinding(scope, node.argument.name)) {
+			replacements.push({
+				start: node.start,
+				end: node.end,
+				value: "\"undefined\""
+			});
+			return;
+		}
+		if (node.type === "MetaProperty") {
+			const owner = findRemovableOwner(node, ancestors);
+			replacements.push({
+				start: owner.start,
+				end: owner.end,
+				value: ""
+			});
+			return;
+		}
+		if (node.type !== "Identifier" || isTypeContext(ancestors) || isInsideTypeof(ancestors) || isInsideImportDeclaration(ancestors)) {
+			return;
+		}
+		if (isPropertyOnlyIdentifier(node, parent)) {
+			return;
+		}
+		const isAlwaysForbidden = alwaysForbiddenIdentifiers.has(node.name);
+		const bindingKey = getBindingKey(scope, node.name);
+		const isDerivedForbidden = bindingKey !== null && derivedForbiddenBindings.has(bindingKey);
+		const isWindowScoped = windowScopedNames.has(node.name) && !hasBinding(scope, node.name);
+		const isForbiddenGlobal = forbiddenGlobals.has(node.name) && !hasBinding(scope, node.name);
+		if (!isAlwaysForbidden && !isDerivedForbidden && !isWindowScoped && !isForbiddenGlobal) {
+			return;
+		}
+		if (!isAlwaysForbidden && isInDeferredFunctionScope(ancestors)) {
+			return;
+		}
+		if (hasHocs && isInsideHocCall(ancestors, hocs, imports)) {
+			return;
+		}
+		if (isBindingPosition(node, parent) && !isAlwaysForbidden) {
+			return;
+		}
+		if (parent?.type === "ExportDefaultDeclaration" && parent.declaration === node) {
+			return;
+		}
+		if (generatedProcessorHelperNameRe.test(node.name) && hasBinding(scope, node.name)) {
+			return;
+		}
+		const generatedHelperDeclarator = findLastAncestor(ancestors, (ancestor) => ancestor.type === "VariableDeclarator" && ancestor.id.type === "Identifier" && generatedProcessorHelperNameRe.test(ancestor.id.name));
+		if (generatedHelperDeclarator) {
+			return;
+		}
+		if (parent?.type === "Property" && parent.value === node && hasBinding(scope, node.name)) {
+			return;
+		}
+		if (parent?.type === "Property" && parent.value === node) {
+			replacements.push({
+				start: node.start,
+				end: node.end,
+				value: parent.shorthand ? `${node.name}: undefined` : "undefined"
+			});
+			return;
+		}
+		const grandparent = ancestors[ancestors.length - 2] ?? null;
+		if (parent?.type === "MemberExpression" && parent.object === node && grandparent?.type === "SpreadElement" && grandparent.argument === parent) {
+			replacements.push({
+				start: grandparent.start,
+				end: grandparent.end,
+				value: "...{}"
+			});
+			return;
+		}
+		const exportProtection = findExportedBindingProtection(node, ancestors, reExportedLocalNames);
+		if (exportProtection) {
+			replacements.push(exportProtection);
+			return;
+		}
+		const promiseOwner = findPromiseCallbackOwner(ancestors);
+		const owner = promiseOwner ? findRemovableOwner(promiseOwner, ancestors) : findRemovableOwner(node, ancestors);
+		replacements.push({
+			start: owner.start,
+			end: owner.end,
+			value: ""
+		});
+	});
+	return applyReplacements(code, normalizeReplacements(replacements));
+};
+//# sourceMappingURL=oxcPreevalTransforms.js.map