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

package/types/utils/collectOxcExportsAndImports.js

@@ -0,0 +1,957 @@
+/* eslint-disable @typescript-eslint/no-use-before-define,no-restricted-syntax,no-continue */
+import { parseOxcCached } from './parseOxc';
+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);
+}