@wyw-in-js/transform 0.1.0

package/types/utils/collectExportsAndImports.js

@@ -0,0 +1,962 @@
+"use strict";
+/* eslint @typescript-eslint/no-use-before-define: ["error", { "functions": false }] */
+/* eslint-disable no-restricted-syntax,no-continue */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectExportsAndImports = exports.explicitImport = exports.sideEffectImport = void 0;
+const shared_1 = require("@wyw-in-js/shared");
+const getScope_1 = require("./getScope");
+const isExports_1 = require("./isExports");
+const isNotNull_1 = require("./isNotNull");
+const isRequire_1 = require("./isRequire");
+const isTypedNode_1 = require("./isTypedNode");
+const traversalCache_1 = require("./traversalCache");
+const sideEffectImport = (item) => item.imported === 'side-effect';
+exports.sideEffectImport = sideEffectImport;
+const explicitImport = (item) => item.imported !== 'side-effect';
+exports.explicitImport = explicitImport;
+function getValue({ node }) {
+    return node.type === 'Identifier' ? node.name : node.value;
+}
+// We ignore imports and exports of types
+const isType = (p) => ('importKind' in p.node && p.node.importKind === 'type') ||
+    ('exportKind' in p.node && p.node.exportKind === 'type');
+const collectors = {
+    ImportSpecifier(path, source) {
+        if (isType(path))
+            return [];
+        const imported = getValue(path.get('imported'));
+        const local = path.get('local');
+        return [{ imported, local, source, type: 'esm' }];
+    },
+    ImportDefaultSpecifier(path, source) {
+        const local = path.get('local');
+        return [{ imported: 'default', local, source, type: 'esm' }];
+    },
+    ImportNamespaceSpecifier(path, source) {
+        const local = path.get('local');
+        return unfoldNamespaceImport({ imported: '*', local, source, type: 'esm' });
+    },
+};
+function collectFromImportDeclaration(path, state) {
+    // If importKind is specified, and it's not a value, ignore that import
+    if (isType(path))
+        return;
+    const source = getValue(path.get('source'));
+    const specifiers = path.get('specifiers');
+    if (specifiers.length === 0) {
+        state.imports.push({ imported: 'side-effect', local: path, source });
+    }
+    specifiers.forEach((specifier) => {
+        if (specifier.isImportSpecifier() && isType(specifier))
+            return;
+        const collector = collectors[specifier.node.type];
+        state.imports.push(...collector(specifier, source));
+    });
+}
+function getAncestorsWhile(path, cond) {
+    const result = [];
+    let current = path;
+    while (current && cond(current)) {
+        result.push(current);
+        current = current.parentPath;
+    }
+    return result;
+}
+function whatIsDestructed(objectPattern) {
+    const destructedProps = [];
+    objectPattern.traverse({
+        Identifier(identifier) {
+            if (identifier.isBindingIdentifier()) {
+                const parent = identifier.parentPath;
+                if (parent.isObjectProperty({ value: identifier.node })) {
+                    const chain = getAncestorsWhile(parent, (p) => p !== objectPattern)
+                        .filter((0, isTypedNode_1.isTypedNode)('ObjectProperty'))
+                        .map((p) => {
+                        const key = p.get('key');
+                        if (!key.isIdentifier()) {
+                            // TODO: try to process other type of keys or at least warn about this
+                            return null;
+                        }
+                        return key;
+                    })
+                        .filter(isNotNull_1.isNotNull);
+                    chain.reverse();
+                    if (chain.length > 0) {
+                        destructedProps.push({
+                            what: chain[0].node.name,
+                            as: identifier,
+                        });
+                    }
+                    return;
+                }
+                if (parent.isRestElement({ argument: identifier.node })) {
+                    destructedProps.push({
+                        what: '*',
+                        as: identifier,
+                    });
+                }
+            }
+        },
+    });
+    return destructedProps;
+}
+const debug = shared_1.logger.extend('evaluator:collectExportsAndImports');
+function importFromVariableDeclarator(path, isSync) {
+    const id = path.get('id');
+    if (id.isIdentifier()) {
+        // It's the simplest case when the full namespace is imported
+        return [
+            {
+                as: id,
+                what: '*',
+            },
+        ];
+    }
+    if (!isSync) {
+        // Something went wrong
+        // Is it something like `const { … } = import(…)`?
+        debug('`import` should be awaited');
+        return [];
+    }
+    if (id.isObjectPattern()) {
+        return whatIsDestructed(id);
+    }
+    // What else it can be?
+    debug('importFromVariableDeclarator: unknown type of id %o', id.node.type);
+    return [];
+}
+const findIIFE = (path) => {
+    if (path.isCallExpression() && path.get('callee').isFunctionExpression()) {
+        return path;
+    }
+    if (!path.parentPath) {
+        return null;
+    }
+    return findIIFE(path.parentPath);
+};
+function exportFromVariableDeclarator(path) {
+    const id = path.get('id');
+    const init = path.get('init');
+    // If there is no init and id is an identifier, we should find IIFE
+    if (!init.node && id.isIdentifier()) {
+        const binding = (0, getScope_1.getScope)(path).getBinding(id.node.name);
+        if (!binding) {
+            return {};
+        }
+        const iife = [
+            ...binding.referencePaths,
+            ...binding.constantViolations,
+            binding.path,
+        ]
+            .map(findIIFE)
+            .find(isNotNull_1.isNotNull);
+        if (!iife) {
+            return {};
+        }
+        return {
+            [id.node.name]: iife,
+        };
+    }
+    if (!init || !init.isExpression()) {
+        return {};
+    }
+    if (id.isIdentifier()) {
+        // It is `export const a = 1;`
+        return {
+            [id.node.name]: init,
+        };
+    }
+    if (id.isObjectPattern()) {
+        // It is `export const { a, ...rest } = obj;`
+        return whatIsDestructed(id).reduce((acc, destructed) => ({
+            ...acc,
+            [destructed.as.node.name]: init,
+        }), {});
+    }
+    // What else it can be?
+    debug('exportFromVariableDeclarator: unknown type of id %o', id.node.type);
+    return {};
+}
+function collectFromDynamicImport(path, state) {
+    const { parentPath: callExpression } = path;
+    if (!callExpression.isCallExpression()) {
+        // It's wrong `import`
+        return;
+    }
+    const [sourcePath] = callExpression.get('arguments');
+    if (!sourcePath || !sourcePath.isStringLiteral()) {
+        // Import should have at least one argument, and it should be StringLiteral
+        return;
+    }
+    const source = sourcePath.node.value;
+    let { parentPath: container, key } = callExpression;
+    let isAwaited = false;
+    if (container.isAwaitExpression()) {
+        // If it's not awaited import, it imports the full namespace
+        isAwaited = true;
+        key = container.key;
+        container = container.parentPath;
+    }
+    // Is it `const something = await import("something")`?
+    if (key === 'init' && container.isVariableDeclarator()) {
+        importFromVariableDeclarator(container, isAwaited).map((prop) => state.imports.push({
+            imported: prop.what,
+            local: prop.as,
+            source,
+            type: 'dynamic',
+        }));
+    }
+}
+function getCalleeName(path) {
+    const callee = path.get('callee');
+    if (callee.isIdentifier()) {
+        return callee.node.name;
+    }
+    if (callee.isMemberExpression()) {
+        const property = callee.get('property');
+        if (property.isIdentifier()) {
+            return property.node.name;
+        }
+    }
+    return undefined;
+}
+function getImportExportTypeByInteropFunction(path) {
+    const name = getCalleeName(path);
+    if (name === undefined) {
+        return undefined;
+    }
+    if (name.startsWith('__exportStar')) {
+        return 're-export:*';
+    }
+    if (name.startsWith('_interopRequireDefault') ||
+        name.startsWith('__importDefault')) {
+        return 'default';
+    }
+    if (name.startsWith('_interopRequireWildcard') ||
+        name.startsWith('__importStar') ||
+        name.startsWith('__toESM')) {
+        return 'import:*';
+    }
+    if (name.startsWith('__rest') ||
+        name.startsWith('__objRest') ||
+        name.startsWith('_objectDestructuringEmpty')) {
+        return 'import:*';
+    }
+    return undefined;
+}
+function isAlreadyProcessed(path) {
+    if (path.isCallExpression() &&
+        path.get('callee').isIdentifier({ name: '__toCommonJS' })) {
+        // because its esbuild and we already processed all exports
+        return true;
+    }
+    return false;
+}
+function collectFromRequire(path, state) {
+    if (!(0, isRequire_1.isRequire)(path))
+        return;
+    // This method can be reached many times from multiple visitors for the same path
+    // So we need to check if we already processed it
+    if (state.processedRequires.has(path))
+        return;
+    state.processedRequires.add(path);
+    const { parentPath: callExpression } = path;
+    if (!callExpression.isCallExpression()) {
+        // It's wrong `require`
+        return;
+    }
+    const [sourcePath] = callExpression.get('arguments');
+    if (!sourcePath || !sourcePath.isStringLiteral()) {
+        // Import should have at least one argument, and it should be StringLiteral
+        return;
+    }
+    const source = sourcePath.node.value;
+    const { parentPath: container, key } = callExpression;
+    if (container.isCallExpression() && key === 0) {
+        // It may be transpiled import such as
+        // `var _atomic = _interopRequireDefault(require("@linaria/atomic"));`
+        const imported = getImportExportTypeByInteropFunction(container);
+        if (!imported) {
+            // It's not a transpiled import.
+            // TODO: Can we guess that it's a namespace import?
+            debug('Unknown wrapper of require: %o', container.node.callee);
+            return;
+        }
+        if (imported === 're-export:*') {
+            state.reexports.push({
+                exported: '*',
+                imported: '*',
+                local: path,
+                source,
+            });
+            return;
+        }
+        let { parentPath: variableDeclarator } = container;
+        if (variableDeclarator.isCallExpression()) {
+            if (variableDeclarator.get('callee').isIdentifier({ name: '_extends' })) {
+                variableDeclarator = variableDeclarator.parentPath;
+            }
+        }
+        if (!variableDeclarator.isVariableDeclarator()) {
+            // TODO: Where else it can be?
+            debug('Unexpected require inside %o', variableDeclarator.node.type);
+            return;
+        }
+        const id = variableDeclarator.get('id');
+        if (!id.isIdentifier()) {
+            debug('Id should be Identifier %o', variableDeclarator.node.type);
+            return;
+        }
+        if (imported === 'import:*') {
+            const unfolded = unfoldNamespaceImport({
+                imported: '*',
+                local: id,
+                source,
+                type: 'cjs',
+            });
+            state.imports.push(...unfolded);
+        }
+        else {
+            state.imports.push({
+                imported,
+                local: id,
+                source,
+                type: 'cjs',
+            });
+        }
+    }
+    if (container.isMemberExpression()) {
+        // It is `require('@linaria/shaker').dep`
+        const property = container.get('property');
+        if (!property.isIdentifier() && !property.isStringLiteral()) {
+            debug('Property should be Identifier or StringLiteral %s', property.node.type);
+            return;
+        }
+        const { parentPath: variableDeclarator } = container;
+        if (variableDeclarator.isVariableDeclarator()) {
+            // It is `const … = require('@linaria/shaker').dep`;
+            const id = variableDeclarator.get('id');
+            if (id.isIdentifier()) {
+                state.imports.push({
+                    imported: getValue(property),
+                    local: id,
+                    source,
+                    type: 'cjs',
+                });
+            }
+            else {
+                debug('Id should be Identifier %o', variableDeclarator.node.type);
+            }
+        }
+        else {
+            // Maybe require is passed as an argument to some function?
+            // Just use the whole MemberExpression as a local
+            state.imports.push({
+                imported: getValue(property),
+                local: container,
+                source,
+                type: 'cjs',
+            });
+        }
+        return;
+    }
+    // Is it `const something = require("something")`?
+    if (key === 'init' && container.isVariableDeclarator()) {
+        importFromVariableDeclarator(container, true).forEach((prop) => {
+            if (prop.what === '*') {
+                const unfolded = unfoldNamespaceImport({
+                    imported: '*',
+                    local: prop.as,
+                    source,
+                    type: 'cjs',
+                });
+                state.imports.push(...unfolded);
+            }
+            else {
+                state.imports.push({
+                    imported: prop.what,
+                    local: prop.as,
+                    source,
+                    type: 'cjs',
+                });
+            }
+        });
+    }
+    if (container.isExpressionStatement()) {
+        // Looks like standalone require
+        state.imports.push({
+            imported: 'side-effect',
+            local: container,
+            source,
+        });
+    }
+}
+function collectFromVariableDeclarator(path, state) {
+    let found = false;
+    path.traverse({
+        Identifier(identifierPath) {
+            if ((0, isRequire_1.isRequire)(identifierPath)) {
+                collectFromRequire(identifierPath, state);
+                found = true;
+            }
+        },
+    });
+    if (found) {
+        path.skip();
+    }
+}
+function isChainOfVoidAssignment(path) {
+    const right = path.get('right');
+    if (right.isUnaryExpression({ operator: 'void' })) {
+        return true;
+    }
+    if (right.isAssignmentExpression()) {
+        return isChainOfVoidAssignment(right);
+    }
+    return false;
+}
+function getReturnValue(path) {
+    if (path.node.params.length !== 0)
+        return undefined;
+    const body = path.get('body');
+    if (body.isExpression()) {
+        return body;
+    }
+    if (body.node.body.length === 1) {
+        const returnStatement = body.get('body')?.[0];
+        if (!returnStatement.isReturnStatement())
+            return undefined;
+        const argument = returnStatement.get('argument');
+        if (!argument.isExpression())
+            return undefined;
+        return argument;
+    }
+    return undefined;
+}
+function getGetterValueFromDescriptor(descriptor) {
+    const props = descriptor
+        .get('properties')
+        .filter((0, isTypedNode_1.isTypedNode)('ObjectProperty'));
+    const getter = props.find((p) => p.get('key').isIdentifier({ name: 'get' }));
+    const value = getter?.get('value');
+    if (value?.isFunctionExpression() || value?.isArrowFunctionExpression()) {
+        return getReturnValue(value);
+    }
+    const valueProp = props.find((p) => p.get('key').isIdentifier({ name: 'value' }));
+    const valueValue = valueProp?.get('value');
+    return valueValue?.isExpression() ? valueValue : undefined;
+}
+function addExport(path, exported, state) {
+    function getRelatedImport() {
+        if (path.isMemberExpression()) {
+            const object = path.get('object');
+            if (!object.isIdentifier()) {
+                return undefined;
+            }
+            const objectBinding = object.scope.getBinding(object.node.name);
+            if (!objectBinding) {
+                return undefined;
+            }
+            if (objectBinding.path.isVariableDeclarator()) {
+                collectFromVariableDeclarator(objectBinding.path, state);
+            }
+            const found = state.imports.find((i) => objectBinding.identifier === i.local.node ||
+                objectBinding.referencePaths.some((p) => i.local.isAncestor(p)));
+            if (!found) {
+                return undefined;
+            }
+            const property = path.get('property');
+            let what = '*';
+            if (path.node.computed && property.isStringLiteral()) {
+                what = property.node.value;
+            }
+            else if (!path.node.computed && property.isIdentifier()) {
+                what = property.node.name;
+            }
+            return {
+                import: { ...found, local: path },
+                what,
+            };
+        }
+        return undefined;
+    }
+    const relatedImport = getRelatedImport();
+    if (relatedImport) {
+        // eslint-disable-next-line no-param-reassign
+        state.reexports.push({
+            local: relatedImport.import.local,
+            imported: relatedImport.import.imported,
+            source: relatedImport.import.source,
+            exported,
+        });
+    }
+    else {
+        // eslint-disable-next-line no-param-reassign
+        state.exports[exported] = path;
+    }
+}
+function collectFromExports(path, state) {
+    if (!(0, isExports_1.isExports)(path))
+        return;
+    if (path.parentPath.isMemberExpression({ object: path.node })) {
+        // It is `exports.prop = …`
+        const memberExpression = path.parentPath;
+        const property = memberExpression.get('property');
+        if (!property.isIdentifier() || memberExpression.node.computed) {
+            return;
+        }
+        const exportName = property.node.name;
+        const saveRef = () => {
+            // Save all export.____ usages for later
+            if (!state.exportRefs.has(exportName)) {
+                state.exportRefs.set(exportName, []);
+            }
+            state.exportRefs.get(exportName).push(memberExpression);
+        };
+        const assignmentExpression = memberExpression.parentPath;
+        if (!assignmentExpression.isAssignmentExpression({
+            left: memberExpression.node,
+        })) {
+            // If it's not `exports.prop = …`. Just save it.
+            saveRef();
+            return;
+        }
+        const right = assignmentExpression.get('right');
+        if (isChainOfVoidAssignment(assignmentExpression)) {
+            // It is `exports.foo = void 0`
+            return;
+        }
+        const { name } = property.node;
+        if (name === '__esModule') {
+            // eslint-disable-next-line no-param-reassign
+            state.isEsModule = true;
+            return;
+        }
+        saveRef();
+        // eslint-disable-next-line no-param-reassign
+        state.exports[property.node.name] = right;
+        return;
+    }
+    if (path.parentPath.isCallExpression() &&
+        path.parentPath.get('callee').matchesPattern('Object.defineProperty')) {
+        const [obj, prop, descriptor] = path.parentPath.get('arguments');
+        if (obj?.isIdentifier(path.node) &&
+            prop?.isStringLiteral() &&
+            descriptor?.isObjectExpression()) {
+            if (prop.node.value === '__esModule') {
+                // eslint-disable-next-line no-param-reassign
+                state.isEsModule = true;
+            }
+            else {
+                /**
+                 *  Object.defineProperty(exports, "token", {
+                 *    enumerable: true,
+                 *    get: function get() {
+                 *      return _unknownPackage.token;
+                 *    }
+                 *  });
+                 */
+                const exported = prop.node.value;
+                const local = getGetterValueFromDescriptor(descriptor);
+                if (local) {
+                    addExport(local, exported, state);
+                }
+            }
+        }
+        else if (obj?.isIdentifier(path.node) &&
+            prop?.isIdentifier() &&
+            descriptor?.isObjectExpression()) {
+            /**
+             *  Object.defineProperty(exports, key, {
+             *    enumerable: true,
+             *    get: function get() {
+             *      return _unknownPackage[key];
+             *    }
+             *  });
+             */
+            const local = getGetterValueFromDescriptor(descriptor);
+            if (local) {
+                addExport(local, '*', state);
+            }
+        }
+    }
+}
+function collectFromRequireOrExports(path, state) {
+    if ((0, isRequire_1.isRequire)(path)) {
+        collectFromRequire(path, state);
+    }
+    else if ((0, isExports_1.isExports)(path)) {
+        collectFromExports(path, state);
+    }
+}
+function unfoldNamespaceImport(importItem) {
+    const result = [];
+    const { local } = importItem;
+    if (!local.isIdentifier()) {
+        // TODO: handle it
+        return [importItem];
+    }
+    const binding = (0, getScope_1.getScope)(local).getBinding(local.node.name);
+    if (!binding?.referenced) {
+        // Imported namespace is not referenced and probably not used,
+        // but it can have side effects, so we should keep it as is
+        return [importItem];
+    }
+    for (const referencePath of binding?.referencePaths ?? []) {
+        if (referencePath.find((ancestor) => ancestor.isTSType() || ancestor.isFlowType())) {
+            continue;
+        }
+        const { parentPath } = referencePath;
+        if (parentPath?.isMemberExpression() && referencePath.key === 'object') {
+            const property = parentPath.get('property');
+            const object = parentPath.get('object');
+            let imported;
+            if (parentPath.node.computed && property.isStringLiteral()) {
+                imported = property.node.value;
+            }
+            else if (!parentPath.node.computed && property.isIdentifier()) {
+                imported = property.node.name;
+            }
+            else {
+                imported = null;
+            }
+            if (object.isIdentifier() && imported) {
+                result.push({
+                    ...importItem,
+                    imported,
+                    local: parentPath,
+                });
+            }
+            else {
+                result.push(importItem);
+                break;
+            }
+            continue;
+        }
+        if (parentPath?.isVariableDeclarator() && referencePath.key === 'init') {
+            importFromVariableDeclarator(parentPath, true).map((prop) => result.push({ ...importItem, imported: prop.what, local: prop.as }));
+            continue;
+        }
+        if (parentPath?.isCallExpression() &&
+            referencePath.listKey === 'arguments') {
+            // The defined variable is used as a function argument. Let's try to figure out what is imported.
+            const importType = getImportExportTypeByInteropFunction(parentPath);
+            if (!importType) {
+                // Imported value is used as an unknown function argument,
+                // so we can't predict usage and import it as is.
+                result.push(importItem);
+                break;
+            }
+            if (importType === 'default') {
+                result.push({
+                    ...importItem,
+                    imported: 'default',
+                    local: parentPath.get('id'),
+                });
+                continue;
+            }
+            if (importType === 'import:*') {
+                result.push(importItem);
+                break;
+            }
+            debug('unfoldNamespaceImports: unknown import type %o', importType);
+            result.push(importItem);
+            continue;
+        }
+        if (parentPath?.isExportSpecifier() ||
+            parentPath?.isExportDefaultDeclaration()) {
+            // The whole namespace is re-exported
+            result.push(importItem);
+            break;
+        }
+        // Otherwise, we can't predict usage and import it as is
+        // TODO: handle more cases
+        debug('unfoldNamespaceImports: unknown reference %o', referencePath.node.type);
+        result.push(importItem);
+        break;
+    }
+    return result;
+}
+function collectFromExportAllDeclaration(path, state) {
+    if (isType(path))
+        return;
+    const source = path.get('source')?.node?.value;
+    if (!source)
+        return;
+    // It is `export * from './css';`
+    state.reexports.push({
+        exported: '*',
+        imported: '*',
+        local: path,
+        source,
+    });
+}
+function collectFromExportSpecifier(path, source, state) {
+    if (path.isExportSpecifier()) {
+        const exported = getValue(path.get('exported'));
+        if (source) {
+            // It is `export { foo } from './css';`
+            const imported = path.get('local').node.name;
+            state.reexports.push({
+                exported,
+                imported,
+                local: path,
+                source,
+            });
+        }
+        else {
+            const local = path.get('local');
+            // eslint-disable-next-line no-param-reassign
+            state.exports[exported] = local;
+        }
+        return;
+    }
+    if (path.isExportDefaultSpecifier() && source) {
+        // It is `export default from './css';`
+        state.reexports.push({
+            exported: 'default',
+            imported: 'default',
+            local: path,
+            source,
+        });
+    }
+    if (path.isExportNamespaceSpecifier() && source) {
+        const exported = path.get('exported').node.name;
+        // It is `export * as foo from './css';`
+        state.reexports.push({
+            exported,
+            imported: '*',
+            local: path,
+            source,
+        });
+    }
+    // TODO: handle other cases
+    debug('collectFromExportSpecifier: unprocessed ExportSpecifier %o', path.node.type);
+}
+function collectFromExportNamedDeclaration(path, state) {
+    if (isType(path))
+        return;
+    const source = path.get('source')?.node?.value;
+    const specifiers = path.get('specifiers');
+    if (specifiers) {
+        specifiers.forEach((specifier) => collectFromExportSpecifier(specifier, source, state));
+    }
+    const declaration = path.get('declaration');
+    if (declaration.isVariableDeclaration()) {
+        declaration.get('declarations').forEach((declarator) => {
+            // eslint-disable-next-line no-param-reassign
+            state.exports = {
+                ...state.exports,
+                ...exportFromVariableDeclarator(declarator),
+            };
+        });
+    }
+    if (declaration.isTSEnumDeclaration()) {
+        // eslint-disable-next-line no-param-reassign
+        state.exports[declaration.get('id').node.name] = declaration;
+    }
+    if (declaration.isFunctionDeclaration()) {
+        const id = declaration.get('id');
+        if (id.isIdentifier()) {
+            // eslint-disable-next-line no-param-reassign
+            state.exports[id.node.name] = id;
+        }
+    }
+    if (declaration.isClassDeclaration()) {
+        const id = declaration.get('id');
+        if (id.isIdentifier()) {
+            // eslint-disable-next-line no-param-reassign
+            state.exports[id.node.name] = id;
+        }
+    }
+}
+function collectFromExportDefaultDeclaration(path, state) {
+    if (isType(path))
+        return;
+    // eslint-disable-next-line no-param-reassign
+    state.exports.default = path.get('declaration');
+}
+function collectFromAssignmentExpression(path, state) {
+    if (isChainOfVoidAssignment(path)) {
+        return;
+    }
+    const left = path.get('left');
+    const right = path.get('right');
+    let exported;
+    if (left.isMemberExpression() && (0, isExports_1.isExports)(left.get('object'))) {
+        const property = left.get('property');
+        if (property.isIdentifier()) {
+            exported = property.node.name;
+        }
+    }
+    else if ((0, isExports_1.isExports)(left)) {
+        // module.exports = ...
+        if (!isAlreadyProcessed(right)) {
+            exported = 'default';
+        }
+    }
+    if (!exported)
+        return;
+    if (!right.isCallExpression() || !(0, isRequire_1.isRequire)(right.get('callee'))) {
+        // eslint-disable-next-line no-param-reassign
+        state.exports[exported] = right;
+        return;
+    }
+    const sourcePath = right.get('arguments')?.[0];
+    const source = sourcePath.isStringLiteral()
+        ? sourcePath.node.value
+        : undefined;
+    if (!source)
+        return;
+    // It is `exports.foo = require('./css');`
+    if (state.exports[exported]) {
+        // eslint-disable-next-line no-param-reassign
+        delete state.exports[exported];
+    }
+    state.reexports.push({
+        exported,
+        imported: '*',
+        local: path,
+        source,
+    });
+    path.skip();
+}
+function collectFromExportStarCall(path, state) {
+    const [requireCall, exports] = path.get('arguments');
+    if (!(0, isExports_1.isExports)(exports))
+        return;
+    if (!requireCall.isCallExpression())
+        return;
+    const callee = requireCall.get('callee');
+    const sourcePath = requireCall.get('arguments')?.[0];
+    if (!(0, isRequire_1.isRequire)(callee) || !sourcePath.isStringLiteral())
+        return;
+    const source = sourcePath.node.value;
+    if (!source)
+        return;
+    state.reexports.push({
+        exported: '*',
+        imported: '*',
+        local: path,
+        source,
+    });
+    path.skip();
+}
+function collectFromMap(map, state) {
+    const properties = map.get('properties');
+    properties.forEach((property) => {
+        if (!property.isObjectProperty())
+            return;
+        const key = property.get('key');
+        const value = property.get('value');
+        if (!key.isIdentifier())
+            return;
+        const exported = key.node.name;
+        if (!value.isFunction())
+            return;
+        if (value.node.params.length !== 0)
+            return;
+        const returnValue = getReturnValue(value);
+        if (!returnValue)
+            return;
+        addExport(returnValue, exported, state);
+    });
+}
+function collectFromEsbuildExportCall(path, state) {
+    const [sourceExports, map] = path.get('arguments');
+    if (!sourceExports.isIdentifier({ name: 'source_exports' }))
+        return;
+    if (!map.isObjectExpression())
+        return;
+    collectFromMap(map, state);
+    path.skip();
+}
+function collectFromEsbuildReExportCall(path, state) {
+    const [sourceExports, requireCall, exports] = path.get('arguments');
+    if (!sourceExports.isIdentifier({ name: 'source_exports' }))
+        return;
+    if (!requireCall.isCallExpression())
+        return;
+    if (!(0, isExports_1.isExports)(exports))
+        return;
+    const callee = requireCall.get('callee');
+    if (!(0, isRequire_1.isRequire)(callee))
+        return;
+    const sourcePath = requireCall.get('arguments')?.[0];
+    if (!sourcePath.isStringLiteral())
+        return;
+    state.reexports.push({
+        exported: '*',
+        imported: '*',
+        local: path,
+        source: sourcePath.node.value,
+    });
+    path.skip();
+}
+function collectFromSwcExportCall(path, state) {
+    const [exports, map] = path.get('arguments');
+    if (!(0, isExports_1.isExports)(exports))
+        return;
+    if (!map.isObjectExpression())
+        return;
+    collectFromMap(map, state);
+    path.skip();
+}
+function collectFromCallExpression(path, state) {
+    const maybeExportStart = path.get('callee');
+    if (!maybeExportStart.isIdentifier()) {
+        return;
+    }
+    const { name } = maybeExportStart.node;
+    // TypeScript
+    if (name.startsWith('__exportStar')) {
+        collectFromExportStarCall(path, state);
+        return;
+    }
+    // swc
+    if (name === '_exportStar') {
+        collectFromExportStarCall(path, state);
+    }
+    if (name === '_export') {
+        collectFromSwcExportCall(path, state);
+    }
+    // esbuild
+    if (name === '__export') {
+        collectFromEsbuildExportCall(path, state);
+    }
+    if (name === '__reExport') {
+        collectFromEsbuildReExportCall(path, state);
+    }
+}
+function collectExportsAndImports(path, cacheMode = 'enabled') {
+    const localState = {
+        deadExports: [],
+        exportRefs: new Map(),
+        exports: {},
+        imports: [],
+        reexports: [],
+        isEsModule: path.node.sourceType === 'module',
+        processedRequires: new WeakSet(),
+    };
+    const cache = cacheMode !== 'disabled'
+        ? (0, traversalCache_1.getTraversalCache)(path, 'collectExportsAndImports')
+        : undefined;
+    if (cacheMode === 'enabled' && cache?.has(path)) {
+        return cache.get(path) ?? localState;
+    }
+    path.traverse({
+        AssignmentExpression: collectFromAssignmentExpression,
+        CallExpression: collectFromCallExpression,
+        ExportAllDeclaration: collectFromExportAllDeclaration,
+        ExportDefaultDeclaration: collectFromExportDefaultDeclaration,
+        ExportNamedDeclaration: collectFromExportNamedDeclaration,
+        ImportDeclaration: collectFromImportDeclaration,
+        Import: collectFromDynamicImport,
+        Identifier: collectFromRequireOrExports,
+        VariableDeclarator: collectFromVariableDeclarator,
+    }, localState);
+    const { processedRequires, ...state } = localState;
+    cache?.set(path, state);
+    return state;
+}
+exports.collectExportsAndImports = collectExportsAndImports;