@wyw-in-js/transform 1.0.6 → 1.0.7

package/types/transform/generators/rewriteBarrelImports.js

@@ -0,0 +1,815 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteOptimizedBarrelImports = rewriteOptimizedBarrelImports;
+/* eslint-disable no-continue, @typescript-eslint/no-use-before-define, @typescript-eslint/no-explicit-any, no-param-reassign, prefer-destructuring */
+const generator_1 = __importDefault(require("@babel/generator"));
+const t = __importStar(require("@babel/types"));
+const EventEmitter_1 = require("../../utils/EventEmitter");
+const shaker_1 = require("../../shaker");
+const cache_1 = require("../../cache");
+const Entrypoint_1 = require("../Entrypoint");
+const barrelManifest_1 = require("../barrelManifest");
+const createAnalysisServices = (services) => ({
+    ...services,
+    cache: new cache_1.TransformCacheCollection({
+        barrelManifests: services.cache.barrelManifests,
+        exports: services.cache.exports,
+    }),
+    eventEmitter: EventEmitter_1.EventEmitter.dummy,
+});
+const addBinding = (manifest, exported, binding, explicitExports) => {
+    const existing = manifest[exported];
+    if (explicitExports.has(exported)) {
+        return;
+    }
+    if (!existing) {
+        manifest[exported] = binding;
+        return;
+    }
+    if (existing.kind === 'blocked') {
+        return;
+    }
+    if (!isSameBinding(existing, binding)) {
+        manifest[exported] = {
+            kind: 'blocked',
+            reason: 'ambiguous',
+        };
+    }
+};
+const addBlockedExport = (manifest, exported, reason) => {
+    manifest[exported] = {
+        kind: 'blocked',
+        reason,
+    };
+};
+const buildResolvedDependencyMap = (resolvedImports) => new Map(resolvedImports.map((dependency) => [dependency.source, dependency]));
+const cloneExportedName = (name) => t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name);
+const cloneImportedName = (name) => name === 'default' || t.isValidIdentifier(name)
+    ? t.identifier(name)
+    : t.stringLiteral(name);
+const isSameBinding = (left, right) => {
+    if (left.kind !== right.kind) {
+        return false;
+    }
+    if (left.source !== right.source) {
+        return false;
+    }
+    if (left.kind === 'named' && right.kind === 'named') {
+        return left.imported === right.imported;
+    }
+    return true;
+};
+function createAnalysisEntrypoint(services, filename, loadedCode) {
+    return Entrypoint_1.Entrypoint.createRoot(services, filename, ['*'], loadedCode);
+}
+function getUniqueSources(raw) {
+    return Array.from(new Set([
+        ...raw.reexports.map((reexport) => reexport.source),
+        ...raw.exportAll,
+    ]));
+}
+function buildImportsForResolve(raw) {
+    return new Map(getUniqueSources(raw).map((source) => [source, []]));
+}
+function getReexportResolutionMap(resolvedImports) {
+    return new Map(resolvedImports.map((dependency) => [
+        dependency.source,
+        dependency.resolved,
+    ]));
+}
+function isBarrelEntry(entry) {
+    return entry.kind === 'barrel';
+}
+function isRawBarrelManifest(entry) {
+    return 'reexports' in entry;
+}
+function shouldUseDirectExports(reason) {
+    return reason === 'impure';
+}
+const getModuleName = (node) => t.isIdentifier(node) ? node.name : node.value;
+const canEmitNamedReexport = (imported) => imported === 'default' || t.isValidIdentifier(imported);
+function collectOptimizedImports(ast) {
+    const imports = new Map();
+    const addImport = (source, imported) => {
+        if (!imports.has(source)) {
+            imports.set(source, []);
+        }
+        if (!imports.get(source).includes(imported)) {
+            imports.get(source).push(imported);
+        }
+    };
+    const program = ast.program;
+    for (const statement of program.body) {
+        if (t.isImportDeclaration(statement) &&
+            t.isStringLiteral(statement.source)) {
+            if (statement.specifiers.length === 0) {
+                addImport(statement.source.value, 'side-effect');
+                continue;
+            }
+            for (const specifier of statement.specifiers) {
+                if (t.isImportDefaultSpecifier(specifier)) {
+                    addImport(statement.source.value, 'default');
+                    continue;
+                }
+                if (t.isImportNamespaceSpecifier(specifier)) {
+                    addImport(statement.source.value, '*');
+                    continue;
+                }
+                if (t.isImportSpecifier(specifier)) {
+                    addImport(statement.source.value, t.isIdentifier(specifier.imported)
+                        ? specifier.imported.name
+                        : specifier.imported.value);
+                }
+            }
+            continue;
+        }
+        if (t.isExportNamedDeclaration(statement) &&
+            statement.source &&
+            t.isStringLiteral(statement.source)) {
+            for (const specifier of statement.specifiers) {
+                if (t.isExportNamespaceSpecifier(specifier)) {
+                    addImport(statement.source.value, '*');
+                    continue;
+                }
+                if (t.isExportDefaultSpecifier(specifier)) {
+                    addImport(statement.source.value, 'default');
+                    continue;
+                }
+                if (t.isExportSpecifier(specifier)) {
+                    addImport(statement.source.value, getModuleName(specifier.local));
+                }
+            }
+            continue;
+        }
+        if (t.isExportAllDeclaration(statement) &&
+            statement.source &&
+            t.isStringLiteral(statement.source)) {
+            addImport(statement.source.value, '*');
+        }
+    }
+    return imports;
+}
+function groupImportSpecifiers(optimized) {
+    const grouped = new Map();
+    for (const specifier of optimized) {
+        if (!grouped.has(specifier.source)) {
+            grouped.set(specifier.source, {
+                defaults: [],
+                named: [],
+            });
+        }
+        const bucket = grouped.get(specifier.source);
+        if (specifier.kind === 'default') {
+            bucket.defaults.push(t.importDefaultSpecifier(specifier.local));
+            continue;
+        }
+        bucket.named.push(t.importSpecifier(specifier.local, cloneImportedName(specifier.imported)));
+    }
+    const declarations = [];
+    for (const [source, bucket] of grouped) {
+        if (bucket.defaults.length === 0) {
+            declarations.push(t.importDeclaration(bucket.named, t.stringLiteral(source)));
+            continue;
+        }
+        declarations.push(t.importDeclaration([bucket.defaults[0], ...bucket.named], t.stringLiteral(source)));
+        for (const defaultSpecifier of bucket.defaults.slice(1)) {
+            declarations.push(t.importDeclaration([defaultSpecifier], t.stringLiteral(source)));
+        }
+    }
+    return declarations;
+}
+function groupExportSpecifiers(optimized) {
+    const grouped = new Map();
+    for (const specifier of optimized) {
+        if (!grouped.has(specifier.source)) {
+            grouped.set(specifier.source, []);
+        }
+        if (specifier.kind === 'namespace') {
+            grouped
+                .get(specifier.source)
+                .push(t.exportNamespaceSpecifier(t.identifier(specifier.exported)));
+            continue;
+        }
+        grouped
+            .get(specifier.source)
+            .push(t.exportSpecifier(t.identifier(specifier.imported), cloneExportedName(specifier.exported)));
+    }
+    return Array.from(grouped.entries()).map(([source, specifiers]) => t.exportNamedDeclaration(null, specifiers, t.stringLiteral(source)));
+}
+function createImportFallback(statement, fallbackSpecifiers) {
+    if (fallbackSpecifiers.length === 0) {
+        return null;
+    }
+    return t.importDeclaration(fallbackSpecifiers, t.stringLiteral(statement.source.value));
+}
+function createExportFallback(statement, fallbackSpecifiers) {
+    if (!statement.source || fallbackSpecifiers.length === 0) {
+        return null;
+    }
+    return t.exportNamedDeclaration(null, fallbackSpecifiers, t.stringLiteral(statement.source.value));
+}
+function emitRewriteSkipped(action, source, reason) {
+    action.services.eventEmitter.single({
+        file: action.entrypoint.name,
+        kind: 'barrelRewriteSkipped',
+        reason,
+        source,
+    });
+}
+function getManifestExport(manifest, exported) {
+    return manifest.exports[exported] ?? null;
+}
+function* getNamedBinding(analysisServices, targetResolved, imported, stack) {
+    if (stack.has(targetResolved)) {
+        return {
+            kind: 'blocked',
+            reason: 'cycle',
+        };
+    }
+    const targetManifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, targetResolved, stack);
+    if (isBarrelEntry(targetManifest)) {
+        const resolved = getManifestExport(targetManifest, imported);
+        if (resolved) {
+            return resolved;
+        }
+        return {
+            kind: 'blocked',
+            reason: targetManifest.complete ? 'unresolved' : 'unknown-star',
+        };
+    }
+    return {
+        kind: 'named',
+        imported,
+        source: targetResolved,
+    };
+}
+function* getStarCandidates(analysisServices, targetResolved, stack) {
+    if (stack.has(targetResolved)) {
+        return {
+            candidates: [],
+            complete: false,
+        };
+    }
+    const targetManifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, targetResolved, stack);
+    if (isBarrelEntry(targetManifest)) {
+        if (!targetManifest.complete) {
+            return {
+                candidates: [],
+                complete: false,
+            };
+        }
+        return {
+            candidates: Object.entries(targetManifest.exports)
+                .filter(([exported, binding]) => exported !== 'default' && binding.kind !== 'blocked')
+                .map(([exported, binding]) => ({
+                binding: binding,
+                exported,
+            })),
+            complete: true,
+        };
+    }
+    if (!shouldUseDirectExports(targetManifest.reason)) {
+        return {
+            candidates: [],
+            complete: false,
+        };
+    }
+    const exports = yield* getExportsForFile.call(this, analysisServices, targetResolved);
+    return {
+        candidates: exports
+            .filter((exported) => exported !== 'default')
+            .map((exported) => ({
+            binding: {
+                kind: 'named',
+                imported: exported,
+                source: targetResolved,
+            },
+            exported,
+        })),
+        complete: true,
+    };
+}
+function* getExportsForFile(services, filename) {
+    const entrypoint = createAnalysisEntrypoint(services, filename);
+    return yield* this.getNext('getExports', entrypoint, undefined, null);
+}
+function* getOrBuildBarrelManifest(analysisServices, filename, stack = new Set()) {
+    const cached = this.services.cache.get('barrelManifests', filename);
+    if (cached) {
+        this.services.eventEmitter.single({
+            file: filename,
+            kind: 'barrelManifest',
+            status: 'hit',
+        });
+        return cached;
+    }
+    const loadedAndParsed = analysisServices.loadAndParseFn(analysisServices, filename, undefined, analysisServices.log);
+    if (loadedAndParsed.evaluator === 'ignored') {
+        const ignoredEntry = {
+            kind: 'ineligible',
+            reason: 'ignored',
+        };
+        this.services.cache.add('barrelManifests', filename, ignoredEntry);
+        return ignoredEntry;
+    }
+    if (loadedAndParsed.evaluator !== shaker_1.shaker) {
+        const customEntry = {
+            kind: 'ineligible',
+            reason: 'custom-evaluator',
+        };
+        this.services.cache.add('barrelManifests', filename, customEntry);
+        return customEntry;
+    }
+    const analyzed = (0, barrelManifest_1.analyzeBarrelFile)(loadedAndParsed.ast);
+    if (!isRawBarrelManifest(analyzed)) {
+        this.services.cache.add('barrelManifests', filename, analyzed);
+        return analyzed;
+    }
+    const resolveEntrypoint = createAnalysisEntrypoint(analysisServices, filename, loadedAndParsed.code);
+    const resolvedImports = yield* this.getNext('resolveImports', resolveEntrypoint, {
+        imports: buildImportsForResolve(analyzed),
+    }, null);
+    const manifestDependencies = resolvedImports.flatMap((dependency) => dependency.resolved ? [dependency.resolved] : []);
+    const resolutionMap = getReexportResolutionMap(resolvedImports);
+    const manifest = {
+        complete: analyzed.complete,
+        exports: {},
+        kind: 'barrel',
+    };
+    const explicitExports = new Set(analyzed.explicitExports);
+    const nextStack = new Set(stack);
+    nextStack.add(filename);
+    for (const reexport of analyzed.reexports) {
+        explicitExports.add(reexport.exported);
+        const targetResolved = resolutionMap.get(reexport.source);
+        if (!targetResolved) {
+            manifest.complete = false;
+            addBlockedExport(manifest.exports, reexport.exported, 'unresolved');
+            continue;
+        }
+        if (reexport.kind === 'namespace') {
+            const namespaceBinding = yield* getNamespaceBinding.call(this, analysisServices, targetResolved, nextStack);
+            manifest.exports[reexport.exported] = namespaceBinding;
+            if (namespaceBinding.kind === 'blocked') {
+                manifest.complete = false;
+            }
+            continue;
+        }
+        const binding = yield* getNamedBinding.call(this, analysisServices, targetResolved, reexport.imported, nextStack);
+        manifest.exports[reexport.exported] = binding;
+        if (binding.kind === 'blocked') {
+            manifest.complete = false;
+        }
+    }
+    for (const exportAllSource of analyzed.exportAll) {
+        const targetResolved = resolutionMap.get(exportAllSource);
+        if (!targetResolved) {
+            manifest.complete = false;
+            continue;
+        }
+        const { candidates, complete } = yield* getStarCandidates.call(this, analysisServices, targetResolved, nextStack);
+        if (!complete) {
+            manifest.complete = false;
+            continue;
+        }
+        for (const candidate of candidates) {
+            addBinding(manifest.exports, candidate.exported, candidate.binding, explicitExports);
+        }
+    }
+    this.services.cache.add('barrelManifests', filename, manifest);
+    this.services.cache.setCacheDependencies('barrelManifests', filename, manifestDependencies);
+    this.services.eventEmitter.single({
+        complete: manifest.complete,
+        file: filename,
+        kind: 'barrelManifest',
+        status: 'built',
+    });
+    return manifest;
+}
+function* getNamespaceBinding(analysisServices, targetResolved, stack) {
+    if (stack.has(targetResolved)) {
+        return {
+            kind: 'blocked',
+            reason: 'cycle',
+        };
+    }
+    const targetManifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, targetResolved, stack);
+    if (isBarrelEntry(targetManifest)) {
+        return {
+            kind: 'blocked',
+            reason: 'namespace-barrel',
+        };
+    }
+    return {
+        kind: 'namespace',
+        source: targetResolved,
+    };
+}
+function getResolvedDependency(dependencies, source) {
+    return dependencies.get(source);
+}
+function* rewriteImportDeclaration(analysisServices, statement, dependencies) {
+    const dependency = getResolvedDependency(dependencies, statement.source.value);
+    if (!dependency?.resolved) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    const manifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, dependency.resolved);
+    if (!isBarrelEntry(manifest)) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    const optimized = [];
+    const fallback = [];
+    for (const specifier of statement.specifiers) {
+        if (t.isImportNamespaceSpecifier(specifier)) {
+            fallback.push(specifier);
+            continue;
+        }
+        if (t.isImportDefaultSpecifier(specifier)) {
+            const binding = getManifestExport(manifest, 'default');
+            if (binding?.kind === 'named' && binding.imported === 'default') {
+                optimized.push({
+                    kind: 'default',
+                    local: specifier.local,
+                    source: binding.source,
+                });
+                continue;
+            }
+            if (binding?.kind === 'blocked') {
+                emitRewriteSkipped(this, statement.source.value, binding.reason);
+            }
+            fallback.push(specifier);
+            continue;
+        }
+        const imported = t.isIdentifier(specifier.imported)
+            ? specifier.imported.name
+            : specifier.imported.value;
+        const binding = getManifestExport(manifest, imported);
+        if (binding?.kind === 'named') {
+            optimized.push({
+                imported: binding.imported,
+                kind: 'named',
+                local: specifier.local,
+                source: binding.source,
+            });
+            continue;
+        }
+        if (binding?.kind === 'blocked') {
+            emitRewriteSkipped(this, statement.source.value, binding.reason);
+        }
+        fallback.push(specifier);
+    }
+    if (optimized.length === 0) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    const rewritten = groupImportSpecifiers(optimized);
+    const fallbackDeclaration = createImportFallback(statement, fallback);
+    const mode = fallbackDeclaration ? 'partial' : 'full';
+    this.services.eventEmitter.single({
+        file: this.entrypoint.name,
+        kind: 'barrelRewrite',
+        mode,
+        optimized: optimized.length,
+        source: statement.source.value,
+    });
+    return {
+        generatedSources: Array.from(new Set(optimized.map((specifier) => specifier.source))),
+        mode,
+        statements: fallbackDeclaration
+            ? [fallbackDeclaration, ...rewritten]
+            : rewritten,
+    };
+}
+function* rewriteExportNamedDeclaration(analysisServices, statement, dependencies) {
+    if (!statement.source || !t.isStringLiteral(statement.source)) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    const dependency = getResolvedDependency(dependencies, statement.source.value);
+    if (!dependency?.resolved) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    const manifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, dependency.resolved);
+    if (!isBarrelEntry(manifest)) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    const optimized = [];
+    const fallback = [];
+    for (const specifier of statement.specifiers) {
+        if (t.isExportNamespaceSpecifier(specifier)) {
+            fallback.push(specifier);
+            continue;
+        }
+        if (t.isExportDefaultSpecifier(specifier)) {
+            const binding = getManifestExport(manifest, 'default');
+            if (binding?.kind === 'named' && binding.imported === 'default') {
+                optimized.push({
+                    exported: getModuleName(specifier.exported),
+                    imported: 'default',
+                    kind: 'named',
+                    source: binding.source,
+                });
+                continue;
+            }
+            if (binding?.kind === 'blocked') {
+                emitRewriteSkipped(this, statement.source.value, binding.reason);
+            }
+            fallback.push(specifier);
+            continue;
+        }
+        const imported = getModuleName(specifier.local);
+        const exported = getModuleName(specifier.exported);
+        const binding = getManifestExport(manifest, imported);
+        if (binding?.kind === 'named' && canEmitNamedReexport(binding.imported)) {
+            optimized.push({
+                exported,
+                imported: binding.imported,
+                kind: 'named',
+                source: binding.source,
+            });
+            continue;
+        }
+        if (binding?.kind === 'namespace' && t.isValidIdentifier(exported)) {
+            optimized.push({
+                exported,
+                kind: 'namespace',
+                source: binding.source,
+            });
+            continue;
+        }
+        if (binding?.kind === 'blocked') {
+            emitRewriteSkipped(this, statement.source.value, binding.reason);
+        }
+        fallback.push(specifier);
+    }
+    if (optimized.length === 0) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    const rewritten = groupExportSpecifiers(optimized);
+    const fallbackDeclaration = createExportFallback(statement, fallback);
+    const mode = fallbackDeclaration ? 'partial' : 'full';
+    this.services.eventEmitter.single({
+        file: this.entrypoint.name,
+        kind: 'barrelRewrite',
+        mode,
+        optimized: optimized.length,
+        source: statement.source.value,
+    });
+    return {
+        generatedSources: Array.from(new Set(optimized.map((specifier) => specifier.source))),
+        mode,
+        statements: fallbackDeclaration
+            ? [fallbackDeclaration, ...rewritten]
+            : rewritten,
+    };
+}
+function* rewriteExportAllDeclaration(analysisServices, statement, dependencies) {
+    const dependency = getResolvedDependency(dependencies, statement.source.value);
+    if (!dependency?.resolved) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    const manifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, dependency.resolved);
+    if (!isBarrelEntry(manifest) || !manifest.complete) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    const optimized = [];
+    let hasUnrewritableExport = false;
+    for (const [exported, binding] of Object.entries(manifest.exports)) {
+        if (exported === 'default' || binding.kind === 'blocked') {
+            continue;
+        }
+        if (binding.kind === 'namespace') {
+            if (!t.isValidIdentifier(exported)) {
+                emitRewriteSkipped(this, statement.source.value, 'namespace-barrel');
+                hasUnrewritableExport = true;
+                continue;
+            }
+            optimized.push({
+                exported,
+                kind: 'namespace',
+                source: binding.source,
+            });
+            continue;
+        }
+        if (!canEmitNamedReexport(binding.imported)) {
+            emitRewriteSkipped(this, statement.source.value, 'unknown-star');
+            hasUnrewritableExport = true;
+            continue;
+        }
+        optimized.push({
+            exported,
+            imported: binding.imported,
+            kind: 'named',
+            source: binding.source,
+        });
+    }
+    if (hasUnrewritableExport) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [statement],
+        };
+    }
+    if (optimized.length === 0) {
+        this.services.eventEmitter.single({
+            file: this.entrypoint.name,
+            kind: 'barrelRewrite',
+            mode: 'full',
+            optimized: 0,
+            source: statement.source.value,
+        });
+        return {
+            generatedSources: [],
+            mode: 'full',
+            statements: [],
+        };
+    }
+    this.services.eventEmitter.single({
+        complete: true,
+        file: this.entrypoint.name,
+        kind: 'barrelRewrite',
+        mode: 'full',
+        optimized: optimized.length,
+        source: statement.source.value,
+    });
+    return {
+        generatedSources: Array.from(new Set(optimized.map((specifier) => specifier.source))),
+        mode: 'full',
+        statements: groupExportSpecifiers(optimized),
+    };
+}
+function* rewriteOptimizedBarrelImports(ast, code, resolvedImports) {
+    const dependencies = buildResolvedDependencyMap(resolvedImports);
+    const analysisServices = createAnalysisServices(this.services);
+    const nextBody = [];
+    const generatedSources = new Set();
+    let optimizedCount = 0;
+    const sourceModes = new Map();
+    let skippedCount = 0;
+    const recordSourceMode = (source, mode, statementChanged) => {
+        if (mode === 'unchanged') {
+            return;
+        }
+        if (statementChanged) {
+            optimizedCount += 1;
+        }
+        if (mode === 'partial') {
+            sourceModes.set(source, 'partial');
+            return;
+        }
+        if (!sourceModes.has(source)) {
+            sourceModes.set(source, 'full');
+        }
+    };
+    for (const statement of ast.program.body) {
+        if (t.isImportDeclaration(statement) &&
+            t.isStringLiteral(statement.source)) {
+            const rewritten = yield* rewriteImportDeclaration.call(this, analysisServices, statement, dependencies);
+            recordSourceMode(statement.source.value, rewritten.mode, !(rewritten.statements.length === 1 &&
+                rewritten.statements[0] === statement));
+            for (const source of rewritten.generatedSources) {
+                generatedSources.add(source);
+            }
+            nextBody.push(...rewritten.statements);
+            continue;
+        }
+        if (t.isExportNamedDeclaration(statement) &&
+            statement.source &&
+            t.isStringLiteral(statement.source)) {
+            const rewritten = yield* rewriteExportNamedDeclaration.call(this, analysisServices, statement, dependencies);
+            recordSourceMode(statement.source.value, rewritten.mode, !(rewritten.statements.length === 1 &&
+                rewritten.statements[0] === statement));
+            for (const source of rewritten.generatedSources) {
+                generatedSources.add(source);
+            }
+            nextBody.push(...rewritten.statements);
+            continue;
+        }
+        if (t.isExportAllDeclaration(statement) &&
+            statement.source &&
+            t.isStringLiteral(statement.source)) {
+            const rewritten = yield* rewriteExportAllDeclaration.call(this, analysisServices, statement, dependencies);
+            if (rewritten.mode === 'unchanged' &&
+                rewritten.statements.length === 1 &&
+                rewritten.statements[0] === statement) {
+                skippedCount += 1;
+            }
+            recordSourceMode(statement.source.value, rewritten.mode, !(rewritten.statements.length === 1 &&
+                rewritten.statements[0] === statement));
+            for (const source of rewritten.generatedSources) {
+                generatedSources.add(source);
+            }
+            nextBody.push(...rewritten.statements);
+            continue;
+        }
+        nextBody.push(statement);
+    }
+    ast.program.body = nextBody;
+    const rewrittenCode = (0, generator_1.default)(ast).code;
+    const imports = collectOptimizedImports(ast);
+    const preResolvedImports = Array.from(imports.entries()).flatMap(([source, only]) => {
+        const dependency = dependencies.get(source);
+        if (dependency) {
+            return [
+                {
+                    ...dependency,
+                    only,
+                },
+            ];
+        }
+        if (generatedSources.has(source)) {
+            return [
+                {
+                    only,
+                    resolved: source,
+                    source,
+                },
+            ];
+        }
+        return [];
+    });
+    return {
+        ast,
+        code: rewrittenCode,
+        fullyRewrittenSources: Array.from(sourceModes.entries())
+            .filter(([, mode]) => mode === 'full')
+            .map(([source]) => source),
+        imports,
+        optimizedCount,
+        partialFallbackSources: Array.from(sourceModes.entries())
+            .filter(([, mode]) => mode === 'partial')
+            .map(([source]) => source),
+        preResolvedImports,
+        skippedCount,
+    };
+}