@wyw-in-js/transform 1.0.8 → 2.0.0-alpha.0

package/types/transform/generators/{rewriteBarrelImports.js → rewriteOxcBarrelImports.js}

@@ -1,57 +1,20 @@
-"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");
+/* eslint-disable no-continue, @typescript-eslint/no-use-before-define, @typescript-eslint/no-explicit-any, no-param-reassign */
+import path from 'path';
+import { parseSync } from 'oxc-parser';
+import { oxcShaker } from '../../shaker';
+import { TransformCacheCollection } from '../../cache';
+import { EventEmitter } from '../../utils/EventEmitter';
+import { collectOxcExportsAndImports } from '../../utils/collectOxcExportsAndImports';
+import { analyzeOxcBarrelFile } from '../oxcBarrelManifest';
+import { Entrypoint } from '../Entrypoint';
+const NODE_MODULES_SEGMENT = `${path.sep}node_modules${path.sep}`;
 const createAnalysisServices = (services) => ({
     ...services,
-    cache: new cache_1.TransformCacheCollection({
+    cache: new TransformCacheCollection({
         barrelManifests: services.cache.barrelManifests,
         exports: services.cache.exports,
     }),
-    eventEmitter: EventEmitter_1.EventEmitter.dummy,
+    eventEmitter: EventEmitter.dummy,
 });
 const addBinding = (manifest, exported, binding, explicitExports) => {
     const existing = manifest[exported];
@@ -78,11 +41,26 @@ const addBlockedExport = (manifest, exported, reason) => {
         reason,
     };
 };
+const addImport = (imports, source, imported) => {
+    const bucket = imports.get(source) ?? [];
+    if (!bucket.includes(imported)) {
+        bucket.push(imported);
+    }
+    imports.set(source, bucket);
+};
+const applyReplacements = (code, replacements) => {
+    let result = code;
+    replacements
+        .sort((a, b) => b.start - a.start)
+        .forEach((replacement) => {
+        result =
+            result.slice(0, replacement.start) +
+                replacement.value +
+                result.slice(replacement.end);
+    });
+    return result;
+};
 const 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;
@@ -95,8 +73,43 @@ const isSameBinding = (left, right) => {
     }
     return true;
 };
+const isValidIdentifier = (name) => /^[$A-Z_a-z][$\w]*$/.test(name);
+const canEmitNamedReexport = (imported) => imported === 'default' || isValidIdentifier(imported);
+const quote = (value) => JSON.stringify(value);
+const moduleName = (node) => node.type === 'Literal' ? String(node.value) : node.name;
+const importedNameCode = (name) => name === 'default' || isValidIdentifier(name) ? name : quote(name);
+const exportedNameCode = (name) => isValidIdentifier(name) ? name : quote(name);
+const importSpecifierCode = (specifier) => {
+    if (specifier.kind === 'default') {
+        return specifier.local;
+    }
+    const imported = importedNameCode(specifier.imported);
+    return imported === specifier.local
+        ? imported
+        : `${imported} as ${specifier.local}`;
+};
+const exportSpecifierCode = (specifier) => {
+    if (specifier.kind === 'namespace') {
+        return `* as ${specifier.exported}`;
+    }
+    const imported = importedNameCode(specifier.imported);
+    const exported = exportedNameCode(specifier.exported);
+    return imported === exported ? imported : `${imported} as ${exported}`;
+};
+function parseProgram(code, filename) {
+    const parsed = parseSync(filename, code, {
+        astType: filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js',
+        range: true,
+        sourceType: 'module',
+    });
+    const fatalError = parsed.errors.find((error) => error.severity === 'Error');
+    if (fatalError) {
+        throw new Error(fatalError.message);
+    }
+    return parsed.program;
+}
 function createAnalysisEntrypoint(services, filename, loadedCode) {
-    return Entrypoint_1.Entrypoint.createRoot(services, filename, ['*'], loadedCode);
+    return Entrypoint.createRoot(services, filename, ['*'], loadedCode);
 }
 function getUniqueSources(raw) {
     return Array.from(new Set([
@@ -122,65 +135,62 @@ function isRawBarrelManifest(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) {
+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 collectOptimizedImports(code, filename) {
     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;
+    const program = parseProgram(code, filename);
     for (const statement of program.body) {
-        if (t.isImportDeclaration(statement) &&
-            t.isStringLiteral(statement.source)) {
+        if (statement.type === 'ImportDeclaration') {
+            if (statement.importKind === 'type') {
+                continue;
+            }
             if (statement.specifiers.length === 0) {
-                addImport(statement.source.value, 'side-effect');
+                addImport(imports, statement.source.value, 'side-effect');
                 continue;
             }
             for (const specifier of statement.specifiers) {
-                if (t.isImportDefaultSpecifier(specifier)) {
-                    addImport(statement.source.value, 'default');
+                if (specifier.type === 'ImportSpecifier' &&
+                    specifier.importKind === 'type') {
                     continue;
                 }
-                if (t.isImportNamespaceSpecifier(specifier)) {
-                    addImport(statement.source.value, '*');
+                if (specifier.type === 'ImportDefaultSpecifier') {
+                    addImport(imports, statement.source.value, 'default');
                     continue;
                 }
-                if (t.isImportSpecifier(specifier)) {
-                    addImport(statement.source.value, t.isIdentifier(specifier.imported)
-                        ? specifier.imported.name
-                        : specifier.imported.value);
+                if (specifier.type === 'ImportNamespaceSpecifier') {
+                    addImport(imports, statement.source.value, '*');
+                    continue;
                 }
+                addImport(imports, statement.source.value, moduleName(specifier.imported));
             }
             continue;
         }
-        if (t.isExportNamedDeclaration(statement) &&
-            statement.source &&
-            t.isStringLiteral(statement.source)) {
+        if (statement.type === 'ExportNamedDeclaration' && statement.source) {
+            if (statement.exportKind === 'type') {
+                continue;
+            }
             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));
+                if (specifier.type === 'ExportSpecifier' &&
+                    specifier.exportKind !== 'type') {
+                    addImport(imports, statement.source.value, moduleName(specifier.local));
                 }
             }
             continue;
         }
-        if (t.isExportAllDeclaration(statement) &&
-            statement.source &&
-            t.isStringLiteral(statement.source)) {
-            addImport(statement.source.value, '*');
+        if (statement.type === 'ExportAllDeclaration') {
+            if (statement.exportKind !== 'type') {
+                addImport(imports, statement.source.value, '*');
+            }
         }
     }
     return imports;
@@ -196,64 +206,81 @@ function groupImportSpecifiers(optimized) {
         }
         const bucket = grouped.get(specifier.source);
         if (specifier.kind === 'default') {
-            bucket.defaults.push(t.importDefaultSpecifier(specifier.local));
-            continue;
+            bucket.defaults.push(specifier);
+        }
+        else {
+            bucket.named.push(specifier);
         }
-        bucket.named.push(t.importSpecifier(specifier.local, cloneImportedName(specifier.imported)));
     }
     const declarations = [];
     for (const [source, bucket] of grouped) {
+        const named = bucket.named.map(importSpecifierCode);
         if (bucket.defaults.length === 0) {
-            declarations.push(t.importDeclaration(bucket.named, t.stringLiteral(source)));
+            declarations.push(`import { ${named.join(', ')} } from ${quote(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)));
-        }
+        const firstDefault = importSpecifierCode(bucket.defaults[0]);
+        declarations.push(named.length > 0
+            ? `import ${firstDefault}, { ${named.join(', ')} } from ${quote(source)};`
+            : `import ${firstDefault} from ${quote(source)};`);
+        bucket.defaults.slice(1).forEach((specifier) => {
+            declarations.push(`import ${importSpecifierCode(specifier)} from ${quote(source)};`);
+        });
     }
     return declarations;
 }
 function groupExportSpecifiers(optimized) {
     const grouped = new Map();
+    const namespaceDeclarations = [];
     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)));
+            namespaceDeclarations.push(`export * as ${specifier.exported} from ${quote(specifier.source)};`);
             continue;
         }
-        grouped
-            .get(specifier.source)
-            .push(t.exportSpecifier(t.identifier(specifier.imported), cloneExportedName(specifier.exported)));
+        if (!grouped.has(specifier.source)) {
+            grouped.set(specifier.source, []);
+        }
+        grouped.get(specifier.source).push(specifier);
     }
-    return Array.from(grouped.entries()).map(([source, specifiers]) => t.exportNamedDeclaration(null, specifiers, t.stringLiteral(source)));
+    return [
+        ...namespaceDeclarations,
+        ...Array.from(grouped.entries()).map(([source, specifiers]) => `export { ${specifiers
+            .map(exportSpecifierCode)
+            .join(', ')} } from ${quote(source)};`),
+    ];
 }
-function createImportFallback(statement, fallbackSpecifiers) {
+const sourceLiteral = (source) => quote(source);
+function createImportFallback(code, statement, fallbackSpecifiers) {
     if (fallbackSpecifiers.length === 0) {
         return null;
     }
-    return t.importDeclaration(fallbackSpecifiers, t.stringLiteral(statement.source.value));
+    const defaults = fallbackSpecifiers.filter((specifier) => specifier.type === 'ImportDefaultSpecifier');
+    const namespaces = fallbackSpecifiers.filter((specifier) => specifier.type === 'ImportNamespaceSpecifier');
+    const named = fallbackSpecifiers.filter((specifier) => specifier.type === 'ImportSpecifier');
+    const renderedNamed = named.map((specifier) => code.slice(specifier.start, specifier.end));
+    const source = sourceLiteral(statement.source.value);
+    if (defaults.length > 0) {
+        const prefix = code.slice(defaults[0].start, defaults[0].end);
+        if (namespaces.length > 0) {
+            return `import ${prefix}, ${code.slice(namespaces[0].start, namespaces[0].end)} from ${source};`;
+        }
+        if (renderedNamed.length > 0) {
+            return `import ${prefix}, { ${renderedNamed.join(', ')} } from ${source};`;
+        }
+        return `import ${prefix} from ${source};`;
+    }
+    if (namespaces.length > 0) {
+        return `import ${code.slice(namespaces[0].start, namespaces[0].end)} from ${source};`;
+    }
+    return `import { ${renderedNamed.join(', ')} } from ${source};`;
 }
-function createExportFallback(statement, fallbackSpecifiers) {
+function createExportFallback(code, 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;
+    return `export { ${fallbackSpecifiers
+        .map((specifier) => code.slice(specifier.start, specifier.end))
+        .join(', ')} } from ${sourceLiteral(statement.source.value)};`;
 }
 function* getNamedBinding(analysisServices, targetResolved, imported, stack) {
     if (stack.has(targetResolved)) {
@@ -262,7 +289,7 @@ function* getNamedBinding(analysisServices, targetResolved, imported, stack) {
             reason: 'cycle',
         };
     }
-    const targetManifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, targetResolved, stack);
+    const targetManifest = yield* getOrBuildOxcBarrelManifest.call(this, analysisServices, targetResolved, stack);
     if (isBarrelEntry(targetManifest)) {
         const resolved = getManifestExport(targetManifest, imported);
         if (resolved) {
@@ -284,14 +311,16 @@ function* getStarCandidates(analysisServices, targetResolved, stack) {
         return {
             candidates: [],
             complete: false,
+            dependencies: [],
         };
     }
-    const targetManifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, targetResolved, stack);
+    const targetManifest = yield* getOrBuildOxcBarrelManifest.call(this, analysisServices, targetResolved, stack);
     if (isBarrelEntry(targetManifest)) {
         if (!targetManifest.complete) {
             return {
                 candidates: [],
                 complete: false,
+                dependencies: [],
             };
         }
         return {
@@ -302,15 +331,18 @@ function* getStarCandidates(analysisServices, targetResolved, stack) {
                 exported,
             })),
             complete: true,
+            dependencies: [],
         };
     }
     if (!shouldUseDirectExports(targetManifest.reason)) {
         return {
             candidates: [],
             complete: false,
+            dependencies: [],
         };
     }
     const exports = yield* getExportsForFile.call(this, analysisServices, targetResolved);
+    const dependencies = yield* getWildcardExportDependencies.call(this, analysisServices, targetResolved, stack);
     return {
         candidates: exports
             .filter((exported) => exported !== 'default')
@@ -323,13 +355,47 @@ function* getStarCandidates(analysisServices, targetResolved, stack) {
             exported,
         })),
         complete: true,
+        dependencies,
     };
 }
+function* getWildcardExportDependencies(analysisServices, filename, stack) {
+    if (stack.has(filename)) {
+        return [];
+    }
+    const loadedAndParsed = analysisServices.loadAndParseFn(analysisServices, filename, undefined, analysisServices.log);
+    if (loadedAndParsed.evaluator === 'ignored' ||
+        loadedAndParsed.evaluator !== oxcShaker) {
+        return [];
+    }
+    const exportNames = yield* getExportsForFile.call(this, analysisServices, filename);
+    this.services.cache.add('exports', filename, exportNames);
+    const wildcardReexports = collectOxcExportsAndImports(loadedAndParsed.code, filename).reexports.filter((reexport) => reexport.exported === '*');
+    if (wildcardReexports.length === 0) {
+        return [];
+    }
+    const resolveEntrypoint = createAnalysisEntrypoint(analysisServices, filename, loadedAndParsed.code);
+    const resolvedImports = yield* this.getNext('resolveImports', resolveEntrypoint, {
+        imports: new Map(wildcardReexports.map((reexport) => [reexport.source, []])),
+    }, null);
+    const dependencies = new Set();
+    const nextStack = new Set(stack);
+    nextStack.add(filename);
+    for (const dependency of resolvedImports) {
+        if (!dependency.resolved) {
+            continue;
+        }
+        dependencies.add(dependency.resolved);
+        const nested = yield* getWildcardExportDependencies.call(this, analysisServices, dependency.resolved, nextStack);
+        nested.forEach((item) => dependencies.add(item));
+    }
+    this.services.cache.setCacheDependencies('exports', filename, dependencies);
+    return [...dependencies];
+}
 function* getExportsForFile(services, filename) {
     const entrypoint = createAnalysisEntrypoint(services, filename);
     return yield* this.getNext('getExports', entrypoint, undefined, null);
 }
-function* getOrBuildBarrelManifest(analysisServices, filename, stack = new Set()) {
+function* getOrBuildOxcBarrelManifest(analysisServices, filename, stack = new Set()) {
     const cached = this.services.cache.get('barrelManifests', filename);
     if (cached) {
         this.services.eventEmitter.single({
@@ -340,6 +406,14 @@ function* getOrBuildBarrelManifest(analysisServices, filename, stack = new Set()
         return cached;
     }
     const loadedAndParsed = analysisServices.loadAndParseFn(analysisServices, filename, undefined, analysisServices.log);
+    if (filename.includes(NODE_MODULES_SEGMENT)) {
+        const externalEntry = {
+            kind: 'ineligible',
+            reason: 'custom-evaluator',
+        };
+        this.services.cache.add('barrelManifests', filename, externalEntry);
+        return externalEntry;
+    }
     if (loadedAndParsed.evaluator === 'ignored') {
         const ignoredEntry = {
             kind: 'ineligible',
@@ -348,7 +422,7 @@ function* getOrBuildBarrelManifest(analysisServices, filename, stack = new Set()
         this.services.cache.add('barrelManifests', filename, ignoredEntry);
         return ignoredEntry;
     }
-    if (loadedAndParsed.evaluator !== shaker_1.shaker) {
+    if (loadedAndParsed.evaluator !== oxcShaker) {
         const customEntry = {
             kind: 'ineligible',
             reason: 'custom-evaluator',
@@ -356,7 +430,7 @@ function* getOrBuildBarrelManifest(analysisServices, filename, stack = new Set()
         this.services.cache.add('barrelManifests', filename, customEntry);
         return customEntry;
     }
-    const analyzed = (0, barrelManifest_1.analyzeBarrelFile)(loadedAndParsed.ast);
+    const analyzed = analyzeOxcBarrelFile(loadedAndParsed.code, filename);
     if (!isRawBarrelManifest(analyzed)) {
         this.services.cache.add('barrelManifests', filename, analyzed);
         return analyzed;
@@ -403,7 +477,8 @@ function* getOrBuildBarrelManifest(analysisServices, filename, stack = new Set()
             manifest.complete = false;
             continue;
         }
-        const { candidates, complete } = yield* getStarCandidates.call(this, analysisServices, targetResolved, nextStack);
+        const { candidates, complete, dependencies } = yield* getStarCandidates.call(this, analysisServices, targetResolved, nextStack);
+        manifestDependencies.push(...dependencies);
         if (!complete) {
             manifest.complete = false;
             continue;
@@ -429,7 +504,7 @@ function* getNamespaceBinding(analysisServices, targetResolved, stack) {
             reason: 'cycle',
         };
     }
-    const targetManifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, targetResolved, stack);
+    const targetManifest = yield* getOrBuildOxcBarrelManifest.call(this, analysisServices, targetResolved, stack);
     if (isBarrelEntry(targetManifest)) {
         return {
             kind: 'blocked',
@@ -444,36 +519,36 @@ function* getNamespaceBinding(analysisServices, targetResolved, stack) {
 function getResolvedDependency(dependencies, source) {
     return dependencies.get(source);
 }
-function* rewriteImportDeclaration(analysisServices, statement, dependencies) {
+function* rewriteImportDeclaration(analysisServices, code, statement, dependencies) {
     const dependency = getResolvedDependency(dependencies, statement.source.value);
-    if (!dependency?.resolved) {
+    if (!dependency?.resolved || statement.specifiers.length === 0) {
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
-    const manifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, dependency.resolved);
+    const manifest = yield* getOrBuildOxcBarrelManifest.call(this, analysisServices, dependency.resolved);
     if (!isBarrelEntry(manifest)) {
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
     const optimized = [];
     const fallback = [];
     for (const specifier of statement.specifiers) {
-        if (t.isImportNamespaceSpecifier(specifier)) {
+        if (specifier.type === 'ImportNamespaceSpecifier') {
             fallback.push(specifier);
             continue;
         }
-        if (t.isImportDefaultSpecifier(specifier)) {
+        if (specifier.type === 'ImportDefaultSpecifier') {
             const binding = getManifestExport(manifest, 'default');
             if (binding?.kind === 'named' && binding.imported === 'default') {
                 optimized.push({
                     kind: 'default',
-                    local: specifier.local,
+                    local: specifier.local.name,
                     source: binding.source,
                 });
                 continue;
@@ -484,15 +559,13 @@ function* rewriteImportDeclaration(analysisServices, statement, dependencies) {
             fallback.push(specifier);
             continue;
         }
-        const imported = t.isIdentifier(specifier.imported)
-            ? specifier.imported.name
-            : specifier.imported.value;
+        const imported = moduleName(specifier.imported);
         const binding = getManifestExport(manifest, imported);
         if (binding?.kind === 'named') {
             optimized.push({
                 imported: binding.imported,
                 kind: 'named',
-                local: specifier.local,
+                local: specifier.local.name,
                 source: binding.source,
             });
             continue;
@@ -506,11 +579,11 @@ function* rewriteImportDeclaration(analysisServices, statement, dependencies) {
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
     const rewritten = groupImportSpecifiers(optimized);
-    const fallbackDeclaration = createImportFallback(statement, fallback);
+    const fallbackDeclaration = createImportFallback(code, statement, fallback);
     const mode = fallbackDeclaration ? 'partial' : 'full';
     this.services.eventEmitter.single({
         file: this.entrypoint.name,
@@ -527,12 +600,12 @@ function* rewriteImportDeclaration(analysisServices, statement, dependencies) {
             : rewritten,
     };
 }
-function* rewriteExportNamedDeclaration(analysisServices, statement, dependencies) {
-    if (!statement.source || !t.isStringLiteral(statement.source)) {
+function* rewriteExportNamedDeclaration(analysisServices, code, statement, dependencies) {
+    if (!statement.source) {
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
     const dependency = getResolvedDependency(dependencies, statement.source.value);
@@ -540,43 +613,26 @@ function* rewriteExportNamedDeclaration(analysisServices, statement, dependencie
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
-    const manifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, dependency.resolved);
+    const manifest = yield* getOrBuildOxcBarrelManifest.call(this, analysisServices, dependency.resolved);
     if (!isBarrelEntry(manifest)) {
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
     const optimized = [];
     const fallback = [];
     for (const specifier of statement.specifiers) {
-        if (t.isExportNamespaceSpecifier(specifier)) {
+        if (specifier.type !== 'ExportSpecifier') {
             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 imported = moduleName(specifier.local);
+        const exported = moduleName(specifier.exported);
         const binding = getManifestExport(manifest, imported);
         if (binding?.kind === 'named' && canEmitNamedReexport(binding.imported)) {
             optimized.push({
@@ -587,7 +643,7 @@ function* rewriteExportNamedDeclaration(analysisServices, statement, dependencie
             });
             continue;
         }
-        if (binding?.kind === 'namespace' && t.isValidIdentifier(exported)) {
+        if (binding?.kind === 'namespace' && isValidIdentifier(exported)) {
             optimized.push({
                 exported,
                 kind: 'namespace',
@@ -604,11 +660,11 @@ function* rewriteExportNamedDeclaration(analysisServices, statement, dependencie
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
     const rewritten = groupExportSpecifiers(optimized);
-    const fallbackDeclaration = createExportFallback(statement, fallback);
+    const fallbackDeclaration = createExportFallback(code, statement, fallback);
     const mode = fallbackDeclaration ? 'partial' : 'full';
     this.services.eventEmitter.single({
         file: this.entrypoint.name,
@@ -625,21 +681,28 @@ function* rewriteExportNamedDeclaration(analysisServices, statement, dependencie
             : rewritten,
     };
 }
-function* rewriteExportAllDeclaration(analysisServices, statement, dependencies) {
+function* rewriteExportAllDeclaration(analysisServices, code, statement, dependencies) {
+    if (statement.exported) {
+        return {
+            generatedSources: [],
+            mode: 'unchanged',
+            statements: [code.slice(statement.start, statement.end)],
+        };
+    }
     const dependency = getResolvedDependency(dependencies, statement.source.value);
     if (!dependency?.resolved) {
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
-    const manifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, dependency.resolved);
+    const manifest = yield* getOrBuildOxcBarrelManifest.call(this, analysisServices, dependency.resolved);
     if (!isBarrelEntry(manifest) || !manifest.complete) {
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
     const optimized = [];
@@ -649,7 +712,7 @@ function* rewriteExportAllDeclaration(analysisServices, statement, dependencies)
             continue;
         }
         if (binding.kind === 'namespace') {
-            if (!t.isValidIdentifier(exported)) {
+            if (!isValidIdentifier(exported)) {
                 emitRewriteSkipped(this, statement.source.value, 'namespace-barrel');
                 hasUnrewritableExport = true;
                 continue;
@@ -677,7 +740,7 @@ function* rewriteExportAllDeclaration(analysisServices, statement, dependencies)
         return {
             generatedSources: [],
             mode: 'unchanged',
-            statements: [statement],
+            statements: [code.slice(statement.start, statement.end)],
         };
     }
     if (optimized.length === 0) {
@@ -708,10 +771,11 @@ function* rewriteExportAllDeclaration(analysisServices, statement, dependencies)
         statements: groupExportSpecifiers(optimized),
     };
 }
-function* rewriteOptimizedBarrelImports(ast, code, resolvedImports) {
+export function* rewriteOptimizedOxcBarrelImports(code, filename, resolvedImports) {
     const dependencies = buildResolvedDependencyMap(resolvedImports);
     const analysisServices = createAnalysisServices(this.services);
-    const nextBody = [];
+    const program = parseProgram(code, filename);
+    const replacements = [];
     const generatedSources = new Set();
     let optimizedCount = 0;
     const sourceModes = new Map();
@@ -731,52 +795,45 @@ function* rewriteOptimizedBarrelImports(ast, code, resolvedImports) {
             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);
+    for (const statement of program.body) {
+        let rewritten = null;
+        let source = null;
+        if (statement.type === 'ImportDeclaration') {
+            source = statement.source.value;
+            rewritten = yield* rewriteImportDeclaration.call(this, analysisServices, code, statement, dependencies);
+        }
+        else if (statement.type === 'ExportNamedDeclaration' &&
+            statement.source) {
+            source = statement.source.value;
+            rewritten = yield* rewriteExportNamedDeclaration.call(this, analysisServices, code, statement, dependencies);
+        }
+        else if (statement.type === 'ExportAllDeclaration') {
+            source = statement.source.value;
+            rewritten = yield* rewriteExportAllDeclaration.call(this, analysisServices, code, statement, dependencies);
             if (rewritten.mode === 'unchanged' &&
                 rewritten.statements.length === 1 &&
-                rewritten.statements[0] === statement) {
+                rewritten.statements[0] === code.slice(statement.start, statement.end)) {
                 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);
+        }
+        if (!rewritten || source === null) {
             continue;
         }
-        nextBody.push(statement);
+        const original = code.slice(statement.start, statement.end);
+        const next = rewritten.statements.join('\n');
+        const statementChanged = next !== original;
+        recordSourceMode(source, rewritten.mode, statementChanged);
+        rewritten.generatedSources.forEach((generatedSource) => generatedSources.add(generatedSource));
+        if (statementChanged) {
+            replacements.push({
+                end: statement.end,
+                start: statement.start,
+                value: next,
+            });
+        }
     }
-    ast.program.body = nextBody;
-    const rewrittenCode = (0, generator_1.default)(ast).code;
-    const imports = collectOptimizedImports(ast);
+    const rewrittenCode = replacements.length > 0 ? applyReplacements(code, replacements) : code;
+    const imports = collectOptimizedImports(rewrittenCode, filename);
     const preResolvedImports = Array.from(imports.entries()).flatMap(([source, only]) => {
         const dependency = dependencies.get(source);
         if (dependency) {
@@ -799,11 +856,11 @@ function* rewriteOptimizedBarrelImports(ast, code, resolvedImports) {
         return [];
     });
     return {
-        ast,
         code: rewrittenCode,
         fullyRewrittenSources: Array.from(sourceModes.entries())
             .filter(([, mode]) => mode === 'full')
             .map(([source]) => source),
+        generatedSources: Array.from(generatedSources),
         imports,
         optimizedCount,
         partialFallbackSources: Array.from(sourceModes.entries())