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

package/esm/utils/collectOxcExportsAndImports.js

@@ -0,0 +1,934 @@
+import { parseOxcCached } from "./parseOxc.js";
+const createScope = (parent) => ({
+	bindings: new Map(),
+	parent
+});
+const isNode = (value) => !!value && typeof value === "object" && "type" in value && typeof value.type === "string";
+const localFromNode = (node, code, name) => ({
+	code: code.slice(node.start, node.end),
+	end: node.end,
+	name: name ?? (node.type === "Identifier" ? node.name : undefined),
+	start: node.start
+});
+const nameFromModuleExport = (node) => node.type === "Literal" ? node.value : node.name;
+const nameFromPropertyKey = (key) => {
+	if (key.type === "Identifier") {
+		return key.name;
+	}
+	if (key.type === "Literal" && typeof key.value === "string") {
+		return key.value;
+	}
+	return null;
+};
+const nameFromMemberProperty = (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 defineBinding = (scope, binding) => {
+	scope.bindings.set(binding.name, binding);
+};
+const lookupBinding = (scope, name) => {
+	let current = scope;
+	while (current) {
+		const binding = current.bindings.get(name);
+		if (binding) {
+			return binding;
+		}
+		current = current.parent;
+	}
+	return null;
+};
+const collectBindingNames = (pattern) => {
+	if (pattern.type === "Identifier") {
+		return [pattern.name];
+	}
+	if (pattern.type === "AssignmentPattern") {
+		return collectBindingNames(pattern.left);
+	}
+	if (pattern.type === "ObjectPattern") {
+		return pattern.properties.flatMap((property) => property.type === "RestElement" ? collectBindingNames(property.argument) : collectBindingNames(property.value));
+	}
+	if (pattern.type === "ArrayPattern") {
+		return pattern.elements.flatMap((element) => element ? collectBindingLikeNames(element) : []);
+	}
+	return [];
+};
+const collectBindingLikeNames = (node) => {
+	if (node.type === "RestElement") {
+		return collectBindingLikeNames(node.argument);
+	}
+	if (node.type === "TSParameterProperty") {
+		return collectBindingLikeNames(node.parameter);
+	}
+	return collectBindingNames(node);
+};
+const declareLocalPattern = (scope, pattern) => {
+	collectBindingNames(pattern).forEach((name) => defineBinding(scope, {
+		kind: "local",
+		name
+	}));
+};
+const declareLocalBindingLike = (scope, node) => {
+	collectBindingLikeNames(node).forEach((name) => defineBinding(scope, {
+		kind: "local",
+		name
+	}));
+};
+const isTypeOnlyImport = (declaration, specifier) => declaration.importKind === "type" || specifier?.importKind === "type";
+const isTypeOnlyExport = (declaration) => "exportKind" in declaration && declaration.exportKind === "type";
+const addImport = (state, item) => {
+	state.result.imports.push({
+		imported: item.imported,
+		local: localFromNode(item.local, state.code, item.name),
+		source: item.source,
+		type: item.type
+	});
+};
+const addExport = (state, exported, local, name) => {
+	const { result } = state;
+	result.exports[exported] = localFromNode(local, state.code, name);
+};
+const addReexport = (state, item) => {
+	state.result.reexports.push({
+		exported: item.exported,
+		imported: item.imported,
+		local: localFromNode(item.local, state.code),
+		source: item.source
+	});
+};
+const collectDestructed = (pattern) => pattern.properties.flatMap((property) => {
+	if (property.type === "RestElement") {
+		return collectBindingNames(property.argument).map(() => ({
+			as: property.argument,
+			what: "*"
+		}));
+	}
+	const firstKey = nameFromPropertyKey(property.key);
+	if (!firstKey) {
+		return [];
+	}
+	if (property.value.type === "ObjectPattern") {
+		return collectBindingNames(property.value).map(() => ({
+			as: property.value,
+			what: firstKey
+		}));
+	}
+	if (property.value.type === "ArrayPattern") {
+		return collectBindingNames(property.value).map(() => ({
+			as: property.value,
+			what: firstKey
+		}));
+	}
+	if (property.value.type === "AssignmentPattern") {
+		return collectBindingNames(property.value.left).map(() => ({
+			as: property.value,
+			what: firstKey
+		}));
+	}
+	return collectBindingNames(property.value).map(() => ({
+		as: property.value,
+		what: firstKey
+	}));
+});
+const getStringConstant = (expression) => {
+	if (expression.type === "Literal" && typeof expression.value === "string") {
+		return expression.value;
+	}
+	if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) {
+		return expression.quasis[0]?.value.cooked ?? null;
+	}
+	if (expression.type === "BinaryExpression" && expression.operator === "+") {
+		const left = getStringConstant(expression.left);
+		const right = getStringConstant(expression.right);
+		return left === null || right === null ? null : left + right;
+	}
+	if (expression.type === "CallExpression" && expression.callee.type === "MemberExpression" && nameFromMemberProperty(expression.callee) === "concat") {
+		const base = getStringConstant(expression.callee.object);
+		if (base === null) {
+			return null;
+		}
+		const parts = expression.arguments.map((arg) => arg.type === "SpreadElement" ? null : getStringConstant(arg));
+		if (parts.some((part) => part === null)) {
+			return null;
+		}
+		return [base, ...parts].join("");
+	}
+	if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion" || expression.type === "ParenthesizedExpression") {
+		return getStringConstant(expression.expression);
+	}
+	return null;
+};
+const isRequireCall = (node, scope) => node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "require" && lookupBinding(scope, "require") === null;
+const sourceFromRequireLike = (node, scope, state) => {
+	if (isRequireCall(node, scope)) {
+		const call = node;
+		const [sourceArg] = call.arguments;
+		if (!sourceArg || sourceArg.type === "SpreadElement") {
+			return null;
+		}
+		return getStringConstant(sourceArg);
+	}
+	if (node.type === "Identifier") {
+		return state.requireSources.get(node.name) ?? null;
+	}
+	if (node.type === "CallExpression") {
+		for (const arg of node.arguments) {
+			if (arg.type === "SpreadElement") {
+				continue;
+			}
+			const source = sourceFromRequireLike(arg, scope, state);
+			if (source) {
+				return source;
+			}
+		}
+	}
+	return null;
+};
+const sourceFromDirectRequireBinding = (node, scope, state) => {
+	if (isRequireCall(node, scope)) {
+		const call = node;
+		const [sourceArg] = call.arguments;
+		if (!sourceArg || sourceArg.type === "SpreadElement") {
+			return null;
+		}
+		return getStringConstant(sourceArg);
+	}
+	if (node.type === "Identifier") {
+		return state.requireSources.get(node.name) ?? null;
+	}
+	return null;
+};
+const sourceFromRequireSyntax = (node) => {
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "require") {
+		const [sourceArg] = node.arguments;
+		return sourceArg && sourceArg.type !== "SpreadElement" ? getStringConstant(sourceArg) : null;
+	}
+	if (node.type === "CallExpression") {
+		for (const arg of node.arguments) {
+			if (arg.type === "SpreadElement") {
+				continue;
+			}
+			const source = sourceFromRequireSyntax(arg);
+			if (source) {
+				return source;
+			}
+		}
+	}
+	return null;
+};
+const sourceFromImportedMember = (node, scope, state) => {
+	if (node.type !== "MemberExpression") {
+		return null;
+	}
+	const source = sourceFromRequireLike(node.object, scope, state);
+	const imported = nameFromMemberProperty(node);
+	if (!source || !imported) {
+		return null;
+	}
+	return {
+		imported,
+		source
+	};
+};
+const isExportsObject = (node) => node.type === "Identifier" && node.name === "exports";
+const getExportAssignmentName = (node) => {
+	if (node.type !== "MemberExpression") {
+		return null;
+	}
+	if (isExportsObject(node.object)) {
+		return nameFromMemberProperty(node);
+	}
+	if (node.object.type === "Identifier" && node.object.name === "module" && nameFromMemberProperty(node) === "exports") {
+		return "default";
+	}
+	return null;
+};
+const getCalleeName = (node) => {
+	if (node.type === "Identifier") {
+		return node.name;
+	}
+	if (node.type === "MemberExpression") {
+		return nameFromMemberProperty(node);
+	}
+	return null;
+};
+const getObjectProperty = (objectExpression, name) => {
+	for (const property of objectExpression.properties) {
+		if (property.type === "SpreadElement") {
+			continue;
+		}
+		if (nameFromPropertyKey(property.key) === name) {
+			return property.value;
+		}
+	}
+	return null;
+};
+const getReturnedExpression = (node) => {
+	if (node.type === "ArrowFunctionExpression") {
+		return node.body.type === "BlockStatement" ? getReturnedExpression(node.body) : node.body;
+	}
+	if (node.type === "FunctionExpression" || node.type === "FunctionDeclaration") {
+		return node.body ? getReturnedExpression(node.body) : null;
+	}
+	if (node.type === "BlockStatement") {
+		const returned = node.body.find((statement) => statement.type === "ReturnStatement");
+		return returned?.type === "ReturnStatement" ? returned.argument : null;
+	}
+	return null;
+};
+const collectFromImportDeclaration = (node, scope, state) => {
+	if (isTypeOnlyImport(node)) {
+		return;
+	}
+	const source = node.source.value;
+	if (node.specifiers.length === 0) {
+		addImport(state, {
+			imported: "side-effect",
+			local: node,
+			source,
+			type: "esm"
+		});
+		return;
+	}
+	node.specifiers.forEach((specifier) => {
+		if (specifier.type === "ImportSpecifier" && isTypeOnlyImport(node, specifier)) {
+			return;
+		}
+		if (specifier.type === "ImportNamespaceSpecifier") {
+			const binding = {
+				kind: "namespace",
+				local: localFromNode(specifier.local, state.code, specifier.local.name),
+				name: specifier.local.name,
+				source,
+				type: "esm",
+				used: false
+			};
+			defineBinding(scope, binding);
+			state.namespaces.push(binding);
+			return;
+		}
+		if (specifier.type === "ImportDefaultSpecifier") {
+			defineBinding(scope, {
+				kind: "local",
+				name: specifier.local.name
+			});
+			addImport(state, {
+				imported: "default",
+				local: specifier.local,
+				name: specifier.local.name,
+				source,
+				type: "esm"
+			});
+			return;
+		}
+		defineBinding(scope, {
+			kind: "local",
+			name: specifier.local.name
+		});
+		addImport(state, {
+			imported: nameFromModuleExport(specifier.imported),
+			local: specifier.local,
+			name: specifier.local.name,
+			source,
+			type: "esm"
+		});
+	});
+};
+const collectExportedDeclaration = (declaration, state) => {
+	if (!declaration) {
+		return;
+	}
+	if (declaration.type === "VariableDeclaration") {
+		declaration.declarations.forEach((declarator) => {
+			exportFromVariableDeclarator(declarator, state);
+		});
+		return;
+	}
+	if (declaration.type === "TSEnumDeclaration") {
+		addExport(state, declaration.id.name, declaration.id, declaration.id.name);
+		return;
+	}
+	if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
+		const { id } = declaration;
+		if (id) {
+			addExport(state, id.name, id, id.name);
+		}
+	}
+};
+const collectFromExportNamedDeclaration = (node, state) => {
+	if (isTypeOnlyExport(node)) {
+		return;
+	}
+	const source = node.source?.value;
+	node.specifiers.forEach((specifier) => {
+		if (isTypeOnlyExport(specifier)) {
+			return;
+		}
+		const exported = nameFromModuleExport(specifier.exported);
+		const imported = nameFromModuleExport(specifier.local);
+		if (source) {
+			addReexport(state, {
+				exported,
+				imported,
+				local: specifier,
+				source
+			});
+			return;
+		}
+		addExport(state, exported, specifier.local, imported);
+	});
+	collectExportedDeclaration(node.declaration, state);
+};
+const collectFromExportAllDeclaration = (node, state) => {
+	if (isTypeOnlyExport(node)) {
+		return;
+	}
+	addReexport(state, {
+		exported: node.exported ? nameFromModuleExport(node.exported) : "*",
+		imported: "*",
+		local: node,
+		source: node.source.value
+	});
+};
+const collectFromExportDefaultDeclaration = (node, state) => {
+	if (isTypeOnlyExport(node)) {
+		return;
+	}
+	addExport(state, "default", node.declaration);
+};
+const exportFromVariableDeclarator = (node, state) => {
+	if (node.id.type === "Identifier") {
+		addExport(state, node.id.name, node.init ?? node.id, node.id.name);
+		return;
+	}
+	if (node.id.type === "ObjectPattern") {
+		collectDestructed(node.id).forEach((destructed) => {
+			if (destructed.as.type === "Identifier") {
+				addExport(state, destructed.as.name, node.init ?? destructed.as, destructed.as.name);
+			}
+		});
+		return;
+	}
+	if (node.id.type === "ArrayPattern") {
+		collectBindingNames(node.id).forEach((name) => addExport(state, name, node.init ?? node.id, name));
+	}
+};
+const collectFromImportExpression = (node, parent, state) => {
+	const source = getStringConstant(node.source);
+	if (!source) {
+		return;
+	}
+	let container = parent;
+	let awaited = false;
+	if (container?.type === "AwaitExpression") {
+		awaited = true;
+		container = findParentContainer(container);
+	}
+	if (container?.type === "VariableDeclarator") {
+		importFromVariableDeclarator(container, awaited, source, "dynamic", state);
+	}
+};
+const collectFromWywDynamicImport = (node, parent, state) => {
+	if (node.callee.type !== "Identifier" || node.callee.name !== "__wyw_dynamic_import") {
+		return;
+	}
+	const [sourceArg] = node.arguments;
+	if (!sourceArg || sourceArg.type === "SpreadElement") {
+		return;
+	}
+	const source = getStringConstant(sourceArg);
+	if (!source) {
+		return;
+	}
+	let container = parent;
+	let awaited = false;
+	if (container?.type === "AwaitExpression") {
+		awaited = true;
+		container = findParentContainer(container);
+	}
+	if (container?.type === "VariableDeclarator") {
+		importFromVariableDeclarator(container, awaited, source, "dynamic", state);
+		return;
+	}
+	addImport(state, {
+		imported: "*",
+		local: node,
+		source,
+		type: "dynamic"
+	});
+};
+const parentContainers = new WeakMap();
+const findParentContainer = (node) => parentContainers.get(node) ?? null;
+const importFromVariableDeclarator = (node, isSync, source, type, state) => {
+	if (node.id.type === "Identifier") {
+		addImport(state, {
+			imported: "*",
+			local: node.id,
+			name: node.id.name,
+			source,
+			type
+		});
+		return;
+	}
+	if (!isSync || node.id.type !== "ObjectPattern") {
+		return;
+	}
+	collectDestructed(node.id).forEach((destructed) => {
+		addImport(state, {
+			imported: destructed.what,
+			local: destructed.as,
+			source,
+			type
+		});
+	});
+};
+const collectFromRequireDeclarator = (node, scope, state) => {
+	if (!node.init) {
+		return false;
+	}
+	const memberImport = sourceFromImportedMember(node.init, scope, state);
+	if (memberImport) {
+		if (node.id.type === "Identifier") {
+			defineBinding(scope, {
+				kind: "local",
+				name: node.id.name
+			});
+			addImport(state, {
+				imported: memberImport.imported,
+				local: node.id,
+				name: node.id.name,
+				source: memberImport.source,
+				type: "cjs"
+			});
+		}
+		return true;
+	}
+	const source = sourceFromRequireLike(node.init, scope, state);
+	if (!source) {
+		return false;
+	}
+	if (node.id.type === "Identifier") {
+		state.requireSources.set(node.id.name, source);
+		const binding = {
+			kind: "namespace",
+			local: localFromNode(node.id, state.code, node.id.name),
+			name: node.id.name,
+			source,
+			type: "cjs",
+			used: false
+		};
+		defineBinding(scope, binding);
+		state.namespaces.push(binding);
+		return true;
+	}
+	if (node.id.type === "ObjectPattern") {
+		collectDestructed(node.id).forEach((destructed) => {
+			addImport(state, {
+				imported: destructed.what,
+				local: destructed.as,
+				source,
+				type: "cjs"
+			});
+		});
+		return true;
+	}
+	return false;
+};
+const collectFromNamespaceReference = (node, parent, ctx, state) => {
+	const binding = lookupBinding(ctx.scope, node.name);
+	if (!binding || binding.kind !== "namespace") {
+		return;
+	}
+	if (isBindingPosition(node, parent, ctx.key)) {
+		return;
+	}
+	if (isTypeNode(parent)) {
+		return;
+	}
+	binding.used = true;
+	if (parent?.type === "MemberExpression" && parent.object === node) {
+		const imported = nameFromMemberProperty(parent);
+		addImport(state, {
+			imported: imported ?? "*",
+			local: imported ? parent : node,
+			source: binding.source,
+			type: binding.type
+		});
+		return;
+	}
+	if (parent?.type === "VariableDeclarator" && parent.init === node) {
+		if (parent.id.type === "ObjectPattern") {
+			collectDestructed(parent.id).forEach((destructed) => {
+				addImport(state, {
+					imported: destructed.what,
+					local: destructed.as,
+					source: binding.source,
+					type: binding.type
+				});
+			});
+			return;
+		}
+	}
+	addImport(state, {
+		imported: "*",
+		local: node,
+		name: node.name,
+		source: binding.source,
+		type: binding.type
+	});
+};
+const isBindingPosition = (node, parent, key) => {
+	if (!parent) {
+		return false;
+	}
+	if (parent.type === "ImportNamespaceSpecifier" && key === "local") {
+		return true;
+	}
+	if ((parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier") && key === "local") {
+		return true;
+	}
+	if (parent.type === "VariableDeclarator" && key === "id") {
+		return true;
+	}
+	if (parent.type === "FunctionDeclaration" && key === "id") {
+		return true;
+	}
+	if (parent.type === "ClassDeclaration" && key === "id") {
+		return true;
+	}
+	if (parent.type === "Property" && parent.value === node && parent.key !== node) {
+		return true;
+	}
+	return false;
+};
+const isTypeNode = (node) => !!node && (node.type.startsWith("TS") || node.type.startsWith("JSDoc"));
+const collectFromAssignmentExpression = (node, ctx, state) => {
+	if (node.operator !== "=") {
+		return;
+	}
+	const exported = getExportAssignmentName(node.left);
+	if (!exported || exported === "__esModule") {
+		return;
+	}
+	const imported = sourceFromImportedMember(node.right, ctx.scope, state);
+	if (imported) {
+		addReexport(state, {
+			exported,
+			imported: imported.imported,
+			local: node,
+			source: imported.source
+		});
+		return;
+	}
+	const directRequireSource = sourceFromDirectRequireBinding(node.right, ctx.scope, state);
+	if (directRequireSource) {
+		addReexport(state, {
+			exported,
+			imported: "*",
+			local: node,
+			source: directRequireSource
+		});
+		return;
+	}
+	addExport(state, exported, node.right);
+};
+const collectFromRequireExpressionStatement = (node, scope, state) => {
+	const source = sourceFromDirectRequireBinding(node.expression, scope, state);
+	if (!source) {
+		return;
+	}
+	addImport(state, {
+		imported: "side-effect",
+		local: node.expression,
+		source,
+		type: "cjs"
+	});
+};
+const collectFromDefineProperty = (node, ctx, state) => {
+	if (node.callee.type !== "MemberExpression" || node.callee.object.type !== "Identifier" || node.callee.object.name !== "Object" || nameFromMemberProperty(node.callee) !== "defineProperty") {
+		return false;
+	}
+	const [target, nameArg, descriptor] = node.arguments;
+	if (!target || !nameArg || !descriptor || target.type === "SpreadElement" || nameArg.type === "SpreadElement" || descriptor.type === "SpreadElement" || !isExportsObject(target)) {
+		return false;
+	}
+	const exported = getStringConstant(nameArg);
+	if (!exported || exported === "__esModule") {
+		return true;
+	}
+	if (descriptor.type === "ObjectExpression") {
+		const getter = getObjectProperty(descriptor, "get");
+		const returned = getter ? getReturnedExpression(getter) : null;
+		const imported = returned ? sourceFromImportedMember(returned, ctx.scope, state) : null;
+		if (imported) {
+			addReexport(state, {
+				exported,
+				imported: imported.imported,
+				local: node,
+				source: imported.source
+			});
+			return true;
+		}
+		const directRequireSource = returned ? sourceFromDirectRequireBinding(returned, ctx.scope, state) : null;
+		if (directRequireSource) {
+			addReexport(state, {
+				exported,
+				imported: "*",
+				local: node,
+				source: directRequireSource
+			});
+			return true;
+		}
+		if (returned) {
+			addExport(state, exported, returned);
+			return true;
+		}
+	}
+	addExport(state, exported, node);
+	return true;
+};
+const collectFromHelperCall = (node, ctx, state) => {
+	const callee = getCalleeName(node.callee);
+	if (!callee) {
+		return;
+	}
+	if (collectFromDefineProperty(node, ctx, state)) {
+		return;
+	}
+	if (callee === "forEach" && node.callee.type === "MemberExpression") {
+		const { object } = node.callee;
+		if (object.type === "CallExpression" && object.callee.type === "MemberExpression" && object.callee.object.type === "Identifier" && object.callee.object.name === "Object" && nameFromMemberProperty(object.callee) === "keys") {
+			const [keysArg] = object.arguments;
+			if (keysArg && keysArg.type !== "SpreadElement") {
+				const source = sourceFromRequireLike(keysArg, ctx.scope, state);
+				if (source) {
+					addReexport(state, {
+						exported: "*",
+						imported: "*",
+						local: node,
+						source
+					});
+				}
+			}
+		}
+		return;
+	}
+	if (/(?:^|_)exportStar$/i.test(callee) || callee === "_export_star" || callee === "__reExport") {
+		for (const arg of node.arguments) {
+			if (arg.type === "SpreadElement") {
+				continue;
+			}
+			const source = sourceFromRequireLike(arg, ctx.scope, state);
+			if (source) {
+				addReexport(state, {
+					exported: "*",
+					imported: "*",
+					local: node,
+					source
+				});
+				return;
+			}
+		}
+	}
+	if (callee === "__export" || callee === "_export") {
+		const [firstArg, secondArg] = node.arguments;
+		if (firstArg && firstArg.type !== "SpreadElement") {
+			const source = sourceFromRequireLike(firstArg, ctx.scope, state);
+			if (source) {
+				addReexport(state, {
+					exported: "*",
+					imported: "*",
+					local: node,
+					source
+				});
+				return;
+			}
+		}
+		if (secondArg?.type === "ObjectExpression") {
+			secondArg.properties.forEach((property) => {
+				if (property.type === "SpreadElement") {
+					return;
+				}
+				const exported = nameFromPropertyKey(property.key);
+				const returned = getReturnedExpression(property.value);
+				if (!exported || !returned) {
+					return;
+				}
+				const imported = sourceFromImportedMember(returned, ctx.scope, state);
+				if (imported) {
+					addReexport(state, {
+						exported,
+						imported: imported.imported,
+						local: property,
+						source: imported.source
+					});
+					return;
+				}
+				const directRequireSource = sourceFromDirectRequireBinding(returned, ctx.scope, state);
+				if (directRequireSource) {
+					addReexport(state, {
+						exported,
+						imported: "*",
+						local: property,
+						source: directRequireSource
+					});
+					return;
+				}
+				addExport(state, exported, returned);
+			});
+		}
+	}
+};
+const visit = (node, ctx, state, mode = "all") => {
+	if (mode === "all") {
+		parentContainers.set(node, ctx.parent);
+	}
+	let { scope } = ctx;
+	if (node.type === "Program" || node.type === "BlockStatement" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+		scope = createScope(ctx.scope);
+	}
+	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+		node.params.forEach((param) => declareLocalBindingLike(scope, param));
+	}
+	if (node.type === "ImportDeclaration") {
+		collectFromImportDeclaration(node, scope, state);
+	} else if (mode === "all" && node.type === "ExportNamedDeclaration") {
+		collectFromExportNamedDeclaration(node, state);
+	} else if (mode === "all" && node.type === "ExportAllDeclaration") {
+		collectFromExportAllDeclaration(node, state);
+	} else if (mode === "all" && node.type === "ExportDefaultDeclaration") {
+		collectFromExportDefaultDeclaration(node, state);
+	} else if (node.type === "VariableDeclarator") {
+		if (!collectFromRequireDeclarator(node, scope, state)) {
+			declareLocalPattern(scope, node.id);
+		}
+	} else if (mode === "all" && node.type === "ImportExpression") {
+		collectFromImportExpression(node, ctx.parent, state);
+	} else if (mode === "all" && node.type === "CallExpression") {
+		collectFromWywDynamicImport(node, ctx.parent, state);
+		collectFromHelperCall(node, {
+			...ctx,
+			scope
+		}, state);
+	} else if (mode === "all" && node.type === "ExpressionStatement") {
+		collectFromRequireExpressionStatement(node, scope, state);
+	} else if (mode === "all" && node.type === "AssignmentExpression") {
+		collectFromAssignmentExpression(node, {
+			...ctx,
+			scope
+		}, state);
+	} else if (node.type === "Identifier") {
+		collectFromNamespaceReference(node, ctx.parent, {
+			...ctx,
+			scope
+		}, state);
+	}
+	for (const child of getChildren(node)) {
+		visit(child.node, {
+			key: child.key,
+			parent: node,
+			scope
+		}, state, mode);
+	}
+};
+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({
+				key,
+				node: value
+			});
+			return;
+		}
+		if (Array.isArray(value)) {
+			value.forEach((item) => {
+				if (isNode(item)) {
+					result.push({
+						key,
+						node: item
+					});
+				}
+			});
+		}
+	});
+	return result;
+};
+const precollectRequireSources = (node, state) => {
+	if (node.type === "VariableDeclarator" && node.id.type === "Identifier") {
+		const source = node.init ? sourceFromRequireSyntax(node.init) : null;
+		if (source) {
+			state.requireSources.set(node.id.name, source);
+		}
+	}
+	getChildren(node).forEach((child) => precollectRequireSources(child.node, state));
+};
+const addUnusedNamespaceSideEffects = (state) => {
+	state.namespaces.forEach((binding) => {
+		if (!binding.used) {
+			state.result.imports.push({
+				imported: "side-effect",
+				local: binding.local,
+				source: binding.source,
+				type: binding.type
+			});
+		}
+	});
+};
+export function collectOxcExportsAndImportsFromProgram(program, code, isEsModule) {
+	const rootScope = createScope(null);
+	const state = {
+		code,
+		namespaces: [],
+		requireSources: new Map(),
+		result: {
+			deadExports: [],
+			exports: {},
+			imports: [],
+			isEsModule,
+			reexports: []
+		}
+	};
+	precollectRequireSources(program, state);
+	visit(program, {
+		key: "program",
+		parent: null,
+		scope: rootScope
+	}, state, "all");
+	addUnusedNamespaceSideEffects(state);
+	return state.result;
+}
+export function collectOxcProcessorImportsFromProgram(program, code) {
+	const rootScope = createScope(null);
+	const state = {
+		code,
+		namespaces: [],
+		requireSources: new Map(),
+		result: {
+			deadExports: [],
+			exports: {},
+			imports: [],
+			isEsModule: true,
+			reexports: []
+		}
+	};
+	precollectRequireSources(program, state);
+	visit(program, {
+		key: "program",
+		parent: null,
+		scope: rootScope
+	}, state, "importsOnly");
+	return state.result.imports;
+}
+export function collectOxcExportsAndImports(code, filename) {
+	const parsed = parseOxcCached(filename, code, "unambiguous");
+	return collectOxcExportsAndImportsFromProgram(parsed.program, code, parsed.module.hasModuleSyntax);
+}
+//# sourceMappingURL=collectOxcExportsAndImports.js.map