@js-recon/js-recon 1.3.2 → 1.4.1-alpha.10

package/build/refactor/react/transform.js

@@ -0,0 +1,1852 @@
+var _a;
+import _traverse from "@babel/traverse";
+import _generator from "@babel/generator";
+import * as t from "@babel/types";
+import { tryExtractModuleExportsAssignment, tryExtractExportsAssignment, tryExtractRequireCall, buildModuleExportStatement, makeNamedExportStatement, } from "./helpers.js";
+import { REACT_CANONICAL, JSX_RUNTIME_CANONICAL, REACT_DOM_CLIENT_CANONICAL, REACT_ROUTER_DOM_CANONICAL, librarySource, } from "./library-classify.js";
+const traverse = ((_a = _traverse.default) !== null && _a !== void 0 ? _a : _traverse);
+const generate = _generator.default;
+/**
+ * Transforms a single webpack module function into an array of ES module statements.
+ *
+ * Four passes (all top-level only to avoid placing exports inside nested functions):
+ *   1. `<moduleParam>.exports = <rhs>` → `export * from` or `export default`
+ *   2. `<exportsParam>.<prop> = <rhs>` → named export (all modules with an exportsParam)
+ *   3. Hoist `var x = <requireParam>(N)` to static `import * as x from "./N.js"`
+ *   4. Replace remaining inline `<requireParam>(N)` calls with the hoisted name
+ */
+export const transformModule = (mod) => {
+    const { fnPath, moduleParam, exportsParam, requireParam } = mod;
+    const body = fnPath.node.body;
+    if (!t.isBlockStatement(body))
+        return [];
+    // Pass 1 — handle `<moduleParam>.exports = <rhs>` at the top level only.
+    if (moduleParam) {
+        const next = [];
+        for (const stmt of body.body) {
+            if (!t.isExpressionStatement(stmt)) {
+                next.push(stmt);
+                continue;
+            }
+            const expr = stmt.expression;
+            const directRhs = tryExtractModuleExportsAssignment(expr, moduleParam);
+            if (directRhs) {
+                next.push(buildModuleExportStatement(directRhs, requireParam));
+                continue;
+            }
+            if (t.isSequenceExpression(expr)) {
+                let hadMatch = false;
+                const splitted = [];
+                for (const sub of expr.expressions) {
+                    const rhs = tryExtractModuleExportsAssignment(sub, moduleParam);
+                    if (rhs) {
+                        hadMatch = true;
+                        splitted.push(buildModuleExportStatement(rhs, requireParam));
+                    }
+                    else {
+                        splitted.push(t.expressionStatement(sub));
+                    }
+                }
+                if (hadMatch) {
+                    next.push(...splitted);
+                    continue;
+                }
+            }
+            next.push(stmt);
+        }
+        body.body = next;
+    }
+    // Pass 1.5 — handle webpack ES module registration patterns:
+    //   `<requireParam>.r(<exportsParam>)` → drop (marks module as ES module, not needed in ESM)
+    //   `<requireParam>.d(<exportsParam>, {name: ()=>binding, ...})` → named exports
+    // This handles the common lazy-chunk pattern where webpack emits r.r(t), r.d(t, {default:()=>X})
+    // at the top of the module body instead of the older t.exports = X form.
+    if (requireParam && exportsParam) {
+        const processWebpackRegExpr = (expr) => {
+            if (!t.isCallExpression(expr))
+                return null;
+            const callee = expr.callee;
+            if (!t.isMemberExpression(callee) || callee.computed)
+                return null;
+            if (!t.isIdentifier(callee.object, { name: requireParam }))
+                return null;
+            const method = t.isIdentifier(callee.property) ? callee.property.name : null;
+            if (!method)
+                return null;
+            // r.r(t) → drop
+            if (method === "r" &&
+                expr.arguments.length === 1 &&
+                t.isIdentifier(expr.arguments[0], { name: exportsParam })) {
+                return [];
+            }
+            // r.d(t, {name: ()=>binding, ...}) → named export statements
+            if (method === "d" &&
+                expr.arguments.length >= 2 &&
+                t.isIdentifier(expr.arguments[0], { name: exportsParam }) &&
+                t.isObjectExpression(expr.arguments[1])) {
+                const stmts = [];
+                for (const prop of expr.arguments[1].properties) {
+                    if (!t.isObjectProperty(prop) || prop.computed)
+                        continue;
+                    const key = prop.key;
+                    const val = prop.value;
+                    let propName = null;
+                    if (t.isIdentifier(key))
+                        propName = key.name;
+                    else if (t.isStringLiteral(key))
+                        propName = key.value;
+                    if (!propName)
+                        continue;
+                    // val is typically `() => binding` — unwrap the arrow function body
+                    const exportedVal = t.isArrowFunctionExpression(val) && !t.isBlockStatement(val.body)
+                        ? val.body
+                        : val;
+                    stmts.push(makeNamedExportStatement(propName, exportedVal));
+                }
+                return stmts;
+            }
+            return null;
+        };
+        const next = [];
+        for (const stmt of body.body) {
+            if (!t.isExpressionStatement(stmt)) {
+                next.push(stmt);
+                continue;
+            }
+            const expr = stmt.expression;
+            if (t.isSequenceExpression(expr)) {
+                let hadMatch = false;
+                const splitted = [];
+                for (const sub of expr.expressions) {
+                    const handled = processWebpackRegExpr(sub);
+                    if (handled !== null) {
+                        hadMatch = true;
+                        splitted.push(...handled);
+                    }
+                    else {
+                        splitted.push(t.expressionStatement(sub));
+                    }
+                }
+                if (hadMatch) {
+                    next.push(...splitted);
+                    continue;
+                }
+            }
+            const handled = processWebpackRegExpr(expr);
+            if (handled !== null) {
+                next.push(...handled);
+            }
+            else {
+                next.push(stmt);
+            }
+        }
+        body.body = next;
+    }
+    // Pass 2 — handle `<exportsParam>.<propName> = <rhs>` at the top level only.
+    if (exportsParam) {
+        const next = [];
+        for (const stmt of body.body) {
+            if (!t.isExpressionStatement(stmt)) {
+                next.push(stmt);
+                continue;
+            }
+            const expr = stmt.expression;
+            const direct = tryExtractExportsAssignment(expr, exportsParam);
+            if (direct) {
+                next.push(makeNamedExportStatement(direct.propName, direct.rhs));
+                continue;
+            }
+            if (t.isSequenceExpression(expr)) {
+                const splitted = [];
+                for (const sub of expr.expressions) {
+                    const match = tryExtractExportsAssignment(sub, exportsParam);
+                    if (match) {
+                        splitted.push(makeNamedExportStatement(match.propName, match.rhs));
+                    }
+                    else {
+                        splitted.push(t.expressionStatement(sub));
+                    }
+                }
+                next.push(...splitted);
+                continue;
+            }
+            next.push(stmt);
+        }
+        body.body = next;
+    }
+    // Pass 3 — hoist top-level `var <name> = <requireParam>(N)` to static imports.
+    // moduleSpec → importName
+    const hoistedImports = new Map();
+    // numId → canonical importName (used by Pass 4 for inline replacements)
+    const importNameByNumId = new Map();
+    if (requireParam) {
+        const next = [];
+        for (const stmt of body.body) {
+            if (!t.isVariableDeclaration(stmt)) {
+                next.push(stmt);
+                continue;
+            }
+            const kept = [];
+            for (const decl of stmt.declarations) {
+                if (!t.isIdentifier(decl.id) || !decl.init) {
+                    kept.push(decl);
+                    continue;
+                }
+                const numId = tryExtractRequireCall(decl.init, requireParam);
+                if (numId === null) {
+                    kept.push(decl);
+                    continue;
+                }
+                const spec = `./${numId}.js`;
+                if (!hoistedImports.has(spec)) {
+                    hoistedImports.set(spec, decl.id.name);
+                    importNameByNumId.set(numId, decl.id.name);
+                }
+                // declarator removed (it becomes the static import)
+            }
+            if (kept.length > 0) {
+                next.push(t.variableDeclaration(stmt.kind, kept));
+            }
+        }
+        body.body = next;
+    }
+    // Pass 4 — replace any remaining inline `<requireParam>(N)` calls with a synthesized
+    // namespace import reference.
+    if (requireParam) {
+        fnPath.traverse({
+            CallExpression(p) {
+                const numId = tryExtractRequireCall(p.node, requireParam);
+                if (numId === null)
+                    return;
+                let name = importNameByNumId.get(numId);
+                if (!name) {
+                    name = `_jsr_module_${numId}`;
+                    hoistedImports.set(`./${numId}.js`, name);
+                    importNameByNumId.set(numId, name);
+                }
+                p.replaceWith(t.identifier(name));
+                p.skip();
+            },
+        });
+    }
+    // Pass 4.5 — convert webpack async chunk loading to a true dynamic import:
+    //   requireParam.e(N).then(requireParam.bind(requireParam, N)) → import('./N.js')
+    // This pattern is emitted by webpack for React.lazy() code-split points. After the
+    // outer module wrapper is stripped, `requireParam` is no longer in scope, so the
+    // expression must be replaced before Step 5 removes it.
+    if (requireParam) {
+        fnPath.traverse({
+            CallExpression(callPath) {
+                const node = callPath.node;
+                // Outer call must be X.then(bindExpr) — non-computed member
+                if (!t.isMemberExpression(node.callee) || node.callee.computed)
+                    return;
+                if (!t.isIdentifier(node.callee.property, { name: "then" }))
+                    return;
+                // X must be requireParam.e(numId)
+                const eCallNode = node.callee.object;
+                if (!t.isCallExpression(eCallNode))
+                    return;
+                const eCallee = eCallNode.callee;
+                if (!t.isMemberExpression(eCallee) || eCallee.computed)
+                    return;
+                if (!t.isIdentifier(eCallee.object, { name: requireParam }))
+                    return;
+                if (!t.isIdentifier(eCallee.property, { name: "e" }))
+                    return;
+                const eArgs = eCallNode.arguments;
+                if (eArgs.length !== 1 || !t.isNumericLiteral(eArgs[0]))
+                    return;
+                const numId = eArgs[0].value;
+                // The .then() argument must be requireParam.bind(requireParam, numId)
+                if (node.arguments.length !== 1 || !t.isCallExpression(node.arguments[0]))
+                    return;
+                const bindNode = node.arguments[0];
+                if (!t.isMemberExpression(bindNode.callee) || bindNode.callee.computed)
+                    return;
+                if (!t.isIdentifier(bindNode.callee.object, { name: requireParam }))
+                    return;
+                if (!t.isIdentifier(bindNode.callee.property, { name: "bind" }))
+                    return;
+                const bindArgs = bindNode.arguments;
+                if (bindArgs.length !== 2)
+                    return;
+                if (!t.isIdentifier(bindArgs[0], { name: requireParam }))
+                    return;
+                if (!t.isNumericLiteral(bindArgs[1]) || bindArgs[1].value !== numId)
+                    return;
+                // Replace with import('./N.js') — a dynamic import expression
+                callPath.replaceWith(t.callExpression(t.import(), [t.stringLiteral(`./${numId}.js`)]));
+                callPath.skip();
+            },
+        });
+    }
+    // Step 5 — strip outer function wrapper, prepend hoisted static imports.
+    const importStmts = [];
+    for (const [spec, name] of hoistedImports) {
+        importStmts.push(t.importDeclaration([t.importNamespaceSpecifier(t.identifier(name))], t.stringLiteral(spec)));
+    }
+    return [...importStmts, ...body.body];
+};
+// Returns true when fn matches the webpack runtime require helper:
+//   function X(id) { … return (moduleMap[id](mod, mod.exports, X), mod.exports); }
+// The key signal is the final return statement: a SequenceExpression whose first element
+// is a computed-member CallExpression and whose second is a `<var>.exports` MemberExpression.
+const isWebpackRequireHelper = (fn) => {
+    if (fn.params.length !== 1)
+        return false;
+    for (const stmt of fn.body.body) {
+        if (!t.isReturnStatement(stmt) || !stmt.argument)
+            continue;
+        const arg = stmt.argument;
+        if (!t.isSequenceExpression(arg) || arg.expressions.length !== 2)
+            continue;
+        const [first, second] = arg.expressions;
+        if (!t.isCallExpression(first))
+            continue;
+        if (!t.isMemberExpression(first.callee) || !first.callee.computed)
+            continue;
+        if (!t.isMemberExpression(second))
+            continue;
+        if (!t.isIdentifier(second.property, { name: "exports" }))
+            continue;
+        return true;
+    }
+    return false;
+};
+// ---------------------------------------------------------------------------
+// Pass D helpers — library-aware call-site rewriting
+// ---------------------------------------------------------------------------
+/** Resolves the canonical name for an accessed property on a library-bound local var.
+ *  Returns null if the var is not a known library or the prop has no canonical mapping. */
+function resolveLibraryProp(varName, prop, varToLib) {
+    const info = varToLib.get(varName);
+    if (!info || info.type === "unknown")
+        return null;
+    // Helper: is this name actually a canonical export for this library type?
+    const isCanonical = (name) => {
+        if (info.type === "react")
+            return REACT_CANONICAL.has(name);
+        // Fragment is also exported by react/jsx-runtime but excluded from JSX_RUNTIME_CANONICAL
+        // (which is used only for module classification). Accept it explicitly here for rewriting.
+        if (info.type === "react-jsx-runtime")
+            return JSX_RUNTIME_CANONICAL.has(name) || name === "Fragment";
+        if (info.type === "react-dom-client")
+            return REACT_DOM_CLIENT_CANONICAL.has(name);
+        if (info.type === "react-router-dom")
+            return REACT_ROUTER_DOM_CANONICAL.has(name);
+        return false;
+    };
+    // Check exportMap: only trust the value if it IS a canonical name.
+    // (Avoids mapping e.g. n.jsx = i → canonical 'i' when i is just a local fn.)
+    const viaMap = info.exportMap.get(prop);
+    if (viaMap && isCanonical(viaMap))
+        return { canonical: viaMap, libType: info.type };
+    // Fall back to checking the prop name itself (handles cases where the exported
+    // property name is already the canonical name, e.g. n.jsx = <iife>).
+    if (isCanonical(prop))
+        return { canonical: prop, libType: info.type };
+    return null;
+}
+/** Extracts `varName` and `prop` from a `(0, varName.prop)` or `varName.prop` callee. */
+function tryExtractMemberCallee(callee) {
+    // (0, X.Y) form
+    if (t.isSequenceExpression(callee) && callee.expressions.length === 2) {
+        const [first, second] = callee.expressions;
+        if (t.isNumericLiteral(first) && first.value === 0 && t.isMemberExpression(second)) {
+            const obj = second.object;
+            const prop = second.property;
+            if (t.isIdentifier(obj) && t.isIdentifier(prop) && !second.computed) {
+                return { varName: obj.name, prop: prop.name };
+            }
+        }
+    }
+    // X.Y form
+    if (t.isMemberExpression(callee) && !callee.computed) {
+        const obj = callee.object;
+        const prop = callee.property;
+        if (t.isIdentifier(obj) && t.isIdentifier(prop)) {
+            return { varName: obj.name, prop: prop.name };
+        }
+    }
+    return null;
+}
+/**
+ * Pass D – rewrite library calls and collect which named exports are needed.
+ *
+ * Traverses all statements; for every `(0, X.Y)(args)` or `X.Y(args)` where X is a
+ * known library local var, replaces the callee with the canonical identifier and records
+ * the needed named import.  Also rewrites bare member expressions `X.Y` that are NOT in a
+ * call position (e.g. passed as a value to another function).
+ *
+ * Returns the set of named exports needed per library type so the caller can build
+ * proper `import { ... } from "..."` declarations.
+ */
+function rewriteLibraryCalls(statements, varToLib) {
+    // libType → set of canonical export names actually used
+    const usedExports = new Map();
+    const record = (libType, name) => {
+        const src = librarySource(libType);
+        if (!src)
+            return;
+        if (!usedExports.has(src))
+            usedExports.set(src, new Set());
+        usedExports.get(src).add(name);
+    };
+    const syntheticFile = t.file(t.program(statements, [], "module"));
+    traverse(syntheticFile, {
+        CallExpression(p) {
+            const info = tryExtractMemberCallee(p.node.callee);
+            if (!info)
+                return;
+            const resolved = resolveLibraryProp(info.varName, info.prop, varToLib);
+            if (!resolved)
+                return;
+            record(resolved.libType, resolved.canonical);
+            // Replace (0, X.Y)(...) or X.Y(...) with canonicalName(...)
+            p.node.callee = t.identifier(resolved.canonical);
+            // Do NOT skip — arguments may contain further (0, X.Y)(...) or X.Y member refs.
+        },
+        MemberExpression(p) {
+            // Rewrite X.Y in non-call positions (e.g. passed as callback value)
+            if (p.parent && t.isCallExpression(p.parent) && p.parent.callee === p.node)
+                return; // handled above
+            const obj = p.node.object;
+            const prop = p.node.property;
+            if (!t.isIdentifier(obj) || !t.isIdentifier(prop) || p.node.computed)
+                return;
+            const resolved = resolveLibraryProp(obj.name, prop.name, varToLib);
+            if (!resolved)
+                return;
+            record(resolved.libType, resolved.canonical);
+            p.replaceWith(t.identifier(resolved.canonical));
+            p.skip();
+        },
+        // Rewrite JSX member expressions: <ns.Component> → <CanonicalName>
+        // These are JSXMemberExpression nodes (not MemberExpression), so the visitor above misses them.
+        JSXOpeningElement(p) {
+            const elem = p.node;
+            if (!t.isJSXMemberExpression(elem.name))
+                return;
+            const obj = elem.name.object;
+            const prop = elem.name.property;
+            if (!t.isJSXIdentifier(obj) || !t.isJSXIdentifier(prop))
+                return;
+            const resolved = resolveLibraryProp(obj.name, prop.name, varToLib);
+            if (!resolved)
+                return;
+            record(resolved.libType, resolved.canonical);
+            elem.name = t.jsxIdentifier(resolved.canonical);
+        },
+        JSXClosingElement(p) {
+            const elem = p.node;
+            if (!t.isJSXMemberExpression(elem.name))
+                return;
+            const obj = elem.name.object;
+            const prop = elem.name.property;
+            if (!t.isJSXIdentifier(obj) || !t.isJSXIdentifier(prop))
+                return;
+            const resolved = resolveLibraryProp(obj.name, prop.name, varToLib);
+            if (!resolved)
+                return;
+            // Don't record() again — already recorded from JSXOpeningElement.
+            elem.name = t.jsxIdentifier(resolved.canonical);
+        },
+    });
+    return usedExports;
+}
+// ---------------------------------------------------------------------------
+// Pass E — Babel slicedToArray collapse
+// ---------------------------------------------------------------------------
+/** Returns true if the last arm of a `||` chain is an IIFE that throws TypeError. */
+function isSlicedToArrayTail(node) {
+    if (!t.isCallExpression(node) || node.arguments.length !== 0)
+        return false;
+    const callee = node.callee;
+    if (!t.isFunctionExpression(callee) && !t.isArrowFunctionExpression(callee))
+        return false;
+    const body = callee.body;
+    if (!t.isBlockStatement(body))
+        return false;
+    return body.body.some((s) => t.isThrowStatement(s) &&
+        t.isNewExpression(s.argument) &&
+        t.isIdentifier(s.argument.callee, { name: "TypeError" }));
+}
+function hasSlicedToArrayTail(node) {
+    if (isSlicedToArrayTail(node))
+        return true;
+    if (t.isLogicalExpression(node) && node.operator === "||")
+        return hasSlicedToArrayTail(node.right);
+    return false;
+}
+/**
+ * Tries to detect a `var <temps>, resultVar = (<seqExpr>), target0 = resultVar[0], ...`
+ * pattern produced by Babel's slicedToArray expansion.
+ *
+ * Returns `{ actualExpr, resultVar, targets }` on match, or null.
+ */
+function tryDetectSlicedToArray(decl) {
+    let resultVar = null;
+    let actualExpr = null;
+    for (const d of decl.declarations) {
+        if (!d.init || !t.isSequenceExpression(d.init))
+            continue;
+        const exprs = d.init.expressions;
+        if (exprs.length < 3)
+            continue;
+        // exprs[0]: tempVar = <actualCall>
+        if (!t.isAssignmentExpression(exprs[0]) || exprs[0].operator !== "=")
+            continue;
+        const firstAssign = exprs[0];
+        if (!t.isIdentifier(firstAssign.left))
+            continue;
+        // exprs[1]: countVar = <number>
+        if (!t.isAssignmentExpression(exprs[1]) || !t.isNumericLiteral(exprs[1].right))
+            continue;
+        // last expr: the TypeError IIFE (possibly nested in || chain)
+        if (!hasSlicedToArrayTail(exprs[exprs.length - 1]))
+            continue;
+        resultVar = t.isIdentifier(d.id) ? d.id.name : null;
+        if (!resultVar)
+            continue;
+        actualExpr = firstAssign.right;
+        break;
+    }
+    if (!resultVar || !actualExpr)
+        return null;
+    const targets = [];
+    for (const d of decl.declarations) {
+        if (!d.init || !t.isMemberExpression(d.init))
+            continue;
+        if (!t.isIdentifier(d.init.object, { name: resultVar }))
+            continue;
+        if (!d.init.computed || !t.isNumericLiteral(d.init.property))
+            continue;
+        if (!t.isIdentifier(d.id))
+            continue;
+        targets.push({ id: d.id, index: d.init.property.value });
+    }
+    return targets.length > 0 ? { actualExpr, resultVar, targets } : null;
+}
+/** Collapse Babel slicedToArray expansions in a statement list (including nested blocks). */
+function collapseSlicedToArray(statements) {
+    const out = [];
+    for (const stmt of statements) {
+        // Recurse into block statements (e.g. if/else, function bodies handled via traversal)
+        if (t.isBlockStatement(stmt)) {
+            stmt.body = collapseSlicedToArray(stmt.body);
+            out.push(stmt);
+            continue;
+        }
+        if (!t.isVariableDeclaration(stmt)) {
+            out.push(stmt);
+            continue;
+        }
+        const match = tryDetectSlicedToArray(stmt);
+        if (!match) {
+            out.push(stmt);
+            continue;
+        }
+        const { actualExpr, resultVar, targets } = match;
+        // Sort targets by index so array pattern elements are in order
+        const sorted = [...targets].sort((a, b) => a.index - b.index);
+        const pattern = t.arrayPattern(sorted.map((tgt) => tgt.id));
+        out.push(t.variableDeclaration("const", [t.variableDeclarator(pattern, actualExpr)]));
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Pass E.2 — collapse named slicedToArray helper calls
+// ---------------------------------------------------------------------------
+/**
+ * Detects a named slicedToArray helper function by the TypeError throw at the
+ * end of its body.  Shape: function(e, t) { return ... || (() => { throw new TypeError("...non-iterable...") })() }
+ */
+function isNamedSlicedToArrayHelper(stmt) {
+    if (!t.isFunctionDeclaration(stmt) || !stmt.id || stmt.params.length !== 2)
+        return null;
+    // Direct name match: _slicedToArray is always a Babel array-destructure helper.
+    if (stmt.id.name === "_slicedToArray" || stmt.id.name === "slicedToArray")
+        return stmt.id.name;
+    const body = stmt.body.body;
+    if (body.length === 0)
+        return null;
+    const last = body[body.length - 1];
+    if (!t.isReturnStatement(last) || !last.argument)
+        return null;
+    // The return value must (somewhere in its || chain) throw new TypeError
+    const hasTypeError = (node) => {
+        if (t.isCallExpression(node) &&
+            (t.isFunctionExpression(node.callee) || t.isArrowFunctionExpression(node.callee))) {
+            const innerBody = node.callee.body;
+            if (t.isBlockStatement(innerBody)) {
+                return innerBody.body.some((s) => t.isThrowStatement(s) &&
+                    t.isNewExpression(s.argument) &&
+                    t.isIdentifier(s.argument.callee, { name: "TypeError" }) &&
+                    s.argument.arguments.some((a) => t.isStringLiteral(a) && a.value.includes("non-iterable")));
+            }
+        }
+        if (t.isLogicalExpression(node) && node.operator === "||")
+            return hasTypeError(node.right);
+        return false;
+    };
+    return hasTypeError(last.argument) ? stmt.id.name : null;
+}
+/**
+ * Collapses `const temp = helper(expr, n), a = temp[0], b = temp[1]` into
+ * `const [a, b] = expr` for a given list of statements, knowing which function
+ * names are slicedToArray helpers (passed in as `helperNames`).
+ */
+function collapseSlicedToArrayCalls(stmts, helperNames) {
+    if (helperNames.size === 0)
+        return stmts;
+    const out = [];
+    for (const stmt of stmts) {
+        if (!t.isVariableDeclaration(stmt)) {
+            out.push(stmt);
+            continue;
+        }
+        const decls = stmt.declarations;
+        const newDecls = [];
+        let i = 0;
+        while (i < decls.length) {
+            const d = decls[i];
+            if (!t.isIdentifier(d.id) || !d.init || !t.isCallExpression(d.init)) {
+                newDecls.push(d);
+                i++;
+                continue;
+            }
+            const callExpr = d.init;
+            const callee = callExpr.callee;
+            if (!t.isIdentifier(callee) || !helperNames.has(callee.name)) {
+                newDecls.push(d);
+                i++;
+                continue;
+            }
+            const tempName = d.id.name;
+            let actualExpr = callExpr.arguments[0];
+            // If actualExpr references the immediately preceding declarator, inline its init
+            // so we get `const [a, b] = actualCall` instead of `const _x = actualCall, [a, b] = _x`.
+            if (t.isIdentifier(actualExpr) &&
+                newDecls.length > 0 &&
+                t.isIdentifier(newDecls[newDecls.length - 1].id) &&
+                newDecls[newDecls.length - 1].id.name === actualExpr.name &&
+                newDecls[newDecls.length - 1].init != null) {
+                actualExpr = newDecls[newDecls.length - 1].init;
+                newDecls.pop(); // remove the now-inlined declarator
+            }
+            const targets = [];
+            let j = i + 1;
+            while (j < decls.length) {
+                const nd = decls[j];
+                if (!t.isIdentifier(nd.id) ||
+                    !nd.init ||
+                    !t.isMemberExpression(nd.init) ||
+                    !nd.init.computed ||
+                    !t.isIdentifier(nd.init.object, { name: tempName }) ||
+                    !t.isNumericLiteral(nd.init.property))
+                    break;
+                targets.push({
+                    id: nd.id,
+                    index: nd.init.property.value,
+                });
+                j++;
+            }
+            if (targets.length > 0) {
+                const sorted = [...targets].sort((a, b) => a.index - b.index);
+                const pattern = t.arrayPattern(sorted.map((tgt) => tgt.id));
+                newDecls.push(t.variableDeclarator(pattern, actualExpr));
+                i = j;
+            }
+            else {
+                newDecls.push(d);
+                i++;
+            }
+        }
+        if (newDecls.length > 0)
+            out.push(t.variableDeclaration(stmt.kind, newDecls));
+    }
+    return out;
+}
+/**
+ * Given a list of statements, finds any named slicedToArray helpers, then:
+ * 1. Collapses `const temp = helper(expr, n), a = temp[0], b = temp[1]` → `const [a, b] = expr`
+ * 2. Rewrites inline `helper(expr, n)[k]` → `expr[k]` (single-element extraction with chained access)
+ * 3. Removes the helper declarations once they are no longer referenced.
+ */
+function collapseNamedSlicedToArray(statements) {
+    const helperNames = new Set();
+    for (const stmt of statements) {
+        const name = isNamedSlicedToArrayHelper(stmt);
+        if (name)
+            helperNames.add(name);
+    }
+    if (helperNames.size === 0)
+        return statements;
+    // Remove helper declarations and collapse top-level declarator-sequence usages
+    const withoutHelpers = statements.filter((s) => !(t.isFunctionDeclaration(s) && s.id && helperNames.has(s.id.name)));
+    const topCollapsed = collapseSlicedToArrayCalls(withoutHelpers, helperNames);
+    // Recurse into nested function bodies via traverse — collapse declarator sequences
+    const syntheticFile = t.file(t.program(topCollapsed, [], "module"));
+    traverse(syntheticFile, {
+        BlockStatement(p) {
+            const collapsed = collapseSlicedToArrayCalls(p.node.body, helperNames);
+            if (collapsed !== p.node.body)
+                p.node.body = collapsed;
+        },
+        // Rewrite inline `helper(expr, n)[k]` → `expr[k]`
+        MemberExpression(p) {
+            const node = p.node;
+            if (!node.computed)
+                return;
+            if (!t.isNumericLiteral(node.property))
+                return;
+            if (!t.isCallExpression(node.object))
+                return;
+            const call = node.object;
+            if (!t.isIdentifier(call.callee) || !helperNames.has(call.callee.name))
+                return;
+            const actualExpr = call.arguments[0];
+            if (!actualExpr)
+                return;
+            p.replaceWith(t.memberExpression(actualExpr, node.property, true));
+            p.skip();
+        },
+    });
+    return topCollapsed;
+}
+/** Traverse all function bodies in a statement list and collapse slicedToArray inside them. */
+function collapseSlicedToArrayDeep(statements) {
+    // First collapse named helpers (module-level factored-out slicedToArray function).
+    // This also recurses into all nested function bodies via traverse internally.
+    const afterNamed = collapseNamedSlicedToArray(statements);
+    // Collapse the inline expansion pattern at top level
+    const top = collapseSlicedToArray(afterNamed);
+    // Then recurse into function bodies via a traverse for the inline pattern
+    const syntheticFile = t.file(t.program(top, [], "module"));
+    traverse(syntheticFile, {
+        BlockStatement(p) {
+            const collapsed = collapseSlicedToArray(p.node.body);
+            if (collapsed !== p.node.body) {
+                p.node.body = collapsed;
+            }
+        },
+    });
+    return top;
+}
+// ---------------------------------------------------------------------------
+// Pass F — JSX recovery
+// ---------------------------------------------------------------------------
+function exprToJsxName(expr) {
+    var _a;
+    if (t.isStringLiteral(expr))
+        return t.jsxIdentifier(expr.value);
+    // Handle template literals with no expressions: `div` → "div"
+    if (t.isTemplateLiteral(expr) && expr.expressions.length === 0 && expr.quasis.length === 1) {
+        const raw = (_a = expr.quasis[0].value.cooked) !== null && _a !== void 0 ? _a : expr.quasis[0].value.raw;
+        if (raw)
+            return t.jsxIdentifier(raw);
+    }
+    if (t.isIdentifier(expr))
+        return t.jsxIdentifier(expr.name);
+    if (t.isMemberExpression(expr) && !expr.computed && t.isIdentifier(expr.property)) {
+        const obj = exprToJsxName(expr.object);
+        if (obj)
+            return t.jsxMemberExpression(obj, t.jsxIdentifier(expr.property.name));
+    }
+    return null;
+}
+function exprToJsxAttrValue(expr) {
+    if (t.isStringLiteral(expr))
+        return expr;
+    return t.jsxExpressionContainer(expr);
+}
+function childToJsxChild(child) {
+    var _a;
+    if (t.isStringLiteral(child))
+        return t.jsxText(child.value);
+    // Template literal with no expressions: `Dashboard` → JSXText
+    if (t.isTemplateLiteral(child) && child.expressions.length === 0 && child.quasis.length === 1) {
+        const raw = (_a = child.quasis[0].value.cooked) !== null && _a !== void 0 ? _a : child.quasis[0].value.raw;
+        if (raw !== undefined)
+            return t.jsxText(raw);
+    }
+    if (t.isJSXElement(child) || t.isJSXFragment(child))
+        return child;
+    // Recursively convert nested jsx(...) calls into JSX elements.
+    if (t.isCallExpression(child)) {
+        const converted = tryConvertToJSX(child);
+        if (converted)
+            return converted;
+    }
+    return t.jsxExpressionContainer(child);
+}
+// Detect Babel's compiled object-spread IIFE:
+//   (function(target) { for(var i=1; i<arguments.length; i++){...} return target; })(base, spread1, ...)
+// Returns { base, spreads } if matched, null otherwise.
+function tryUnpackSpreadIIFE(expr) {
+    if (!t.isCallExpression(expr))
+        return null;
+    const callee = expr.callee;
+    if (!t.isFunctionExpression(callee))
+        return null;
+    if (callee.params.length !== 1 || !t.isIdentifier(callee.params[0]))
+        return null;
+    const paramName = callee.params[0].name;
+    const body = callee.body.body;
+    if (body.length < 2)
+        return null;
+    // Must contain a for loop that iterates `arguments.length`
+    const hasArgumentsLoop = body.some((s) => {
+        if (!t.isForStatement(s) || !s.test || !t.isBinaryExpression(s.test))
+            return false;
+        const right = s.test.right;
+        return (s.test.operator === "<" &&
+            t.isMemberExpression(right) &&
+            t.isIdentifier(right.object, { name: "arguments" }) &&
+            t.isIdentifier(right.property, { name: "length" }));
+    });
+    if (!hasArgumentsLoop)
+        return null;
+    // Must return the first param
+    const hasReturn = body.some((s) => t.isReturnStatement(s) && s.argument && t.isIdentifier(s.argument, { name: paramName }));
+    if (!hasReturn)
+        return null;
+    const args = expr.arguments;
+    if (args.length < 1)
+        return null;
+    return { base: args[0], spreads: args.slice(1) };
+}
+/** Build JSXAttributes + children from an ObjectExpression or a spread-IIFE propsArg. */
+function propsArgToAttrsAndChildren(propsArg) {
+    const attrs = [];
+    const childExprs = [];
+    const processObjectExpr = (obj) => {
+        for (const prop of obj.properties) {
+            if (t.isSpreadElement(prop)) {
+                attrs.push(t.jsxSpreadAttribute(prop.argument));
+                continue;
+            }
+            if (!t.isObjectProperty(prop) || prop.computed)
+                continue;
+            const keyNode = prop.key;
+            const valNode = prop.value;
+            const keyName = t.isIdentifier(keyNode) ? keyNode.name : t.isStringLiteral(keyNode) ? keyNode.value : null;
+            if (!keyName)
+                continue;
+            if (keyName === "children") {
+                if (t.isArrayExpression(valNode)) {
+                    for (const el of valNode.elements) {
+                        if (el)
+                            childExprs.push(el);
+                    }
+                }
+                else {
+                    childExprs.push(valNode);
+                }
+                continue;
+            }
+            attrs.push(t.jsxAttribute(t.jsxIdentifier(keyName), exprToJsxAttrValue(valNode)));
+        }
+    };
+    if (t.isObjectExpression(propsArg)) {
+        processObjectExpr(propsArg);
+    }
+    else {
+        // Try to unpack Babel's compiled object-spread IIFE
+        const unpacked = tryUnpackSpreadIIFE(propsArg);
+        if (unpacked) {
+            if (t.isObjectExpression(unpacked.base)) {
+                processObjectExpr(unpacked.base);
+            }
+            else {
+                attrs.push(t.jsxSpreadAttribute(unpacked.base));
+            }
+            for (const spreadExpr of unpacked.spreads) {
+                attrs.push(t.jsxSpreadAttribute(spreadExpr));
+            }
+        }
+        else {
+            // Fallback: emit the entire props argument as a single JSX spread
+            attrs.push(t.jsxSpreadAttribute(propsArg));
+        }
+    }
+    return { attrs, childExprs };
+}
+const JSX_METHOD_NAMES = new Set(["jsx", "jsxs", "jsxDEV"]);
+// Extract the jsx method name from a callee that may be:
+//   - bare identifier: `jsx`
+//   - member expression: `ns.jsx`
+//   - sequence (0, ns.jsx) after a `(0, ...)()` call
+// Returns the method name string, or null if not a jsx call.
+function getJsxMethodName(callee) {
+    if (t.isIdentifier(callee) && JSX_METHOD_NAMES.has(callee.name)) {
+        return callee.name;
+    }
+    if (t.isMemberExpression(callee) && !callee.computed) {
+        const prop = callee.property;
+        if (t.isIdentifier(prop) && JSX_METHOD_NAMES.has(prop.name)) {
+            return prop.name;
+        }
+    }
+    // (0, ns.jsx) sequence expression
+    if (t.isSequenceExpression(callee)) {
+        const exprs = callee.expressions;
+        const last = exprs[exprs.length - 1];
+        if (last && t.isMemberExpression(last) && !last.computed) {
+            const prop = last.property;
+            if (t.isIdentifier(prop) && JSX_METHOD_NAMES.has(prop.name)) {
+                return prop.name;
+            }
+        }
+    }
+    return null;
+}
+function tryConvertToJSX(call) {
+    const callee = call.callee;
+    const methodName = getJsxMethodName(callee);
+    if (!methodName)
+        return null;
+    if (call.arguments.length < 2)
+        return null;
+    const tagArg = call.arguments[0];
+    const propsArg = call.arguments[1];
+    const jsxName = exprToJsxName(tagArg);
+    if (!jsxName)
+        return null;
+    const { attrs, childExprs } = propsArgToAttrsAndChildren(propsArg);
+    const children = childExprs.map((e) => childToJsxChild(e)).filter(Boolean);
+    // Fragment identifier → JSXFragment shorthand (<>...</>)
+    if (t.isJSXIdentifier(jsxName) && jsxName.name === "Fragment") {
+        return t.jsxFragment(t.jsxOpeningFragment(), t.jsxClosingFragment(), children);
+    }
+    const jsxAttrs = attrs.filter((a) => t.isJSXAttribute(a) || t.isJSXSpreadAttribute(a));
+    const selfClosing = children.length === 0;
+    const openingElement = t.jsxOpeningElement(jsxName, jsxAttrs, selfClosing);
+    const closingElement = selfClosing ? null : t.jsxClosingElement(jsxName);
+    return t.jsxElement(openingElement, closingElement, children, selfClosing);
+}
+/** Traverse statements and replace jsx()/jsxs() calls with JSXElement nodes. */
+function recoverJSX(statements) {
+    const syntheticFile = t.file(t.program(statements, [], "module"));
+    traverse(syntheticFile, {
+        CallExpression(p) {
+            const jsxEl = tryConvertToJSX(p.node);
+            if (!jsxEl)
+                return;
+            p.replaceWith(jsxEl);
+            // Do NOT skip — nested jsx calls inside lambdas/expression containers need visiting.
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Pass G — remove top-level Babel helpers and webpack internals
+// ---------------------------------------------------------------------------
+function isBabelArrayLikeToArrayHelper(stmt) {
+    if (!t.isFunctionDeclaration(stmt) || !stmt.id)
+        return false;
+    const body = stmt.body.body;
+    if (body.length < 2 || body.length > 4)
+        return false;
+    // Key signal: contains `for (var ... = Array(n); ...)` and a return of the array
+    const hasArrayOf = body.some((s) => {
+        if (!t.isForStatement(s))
+            return false;
+        const init = s.init;
+        if (!t.isVariableDeclaration(init))
+            return false;
+        return init.declarations.some((d) => d.init &&
+            t.isCallExpression(d.init) &&
+            t.isIdentifier(d.init.callee, { name: "Array" }));
+    });
+    return hasArrayOf;
+}
+// Detect `_typeof` — Babel's lazy-init typeof polyfill.
+// Shape: 1-param function whose sole body statement is
+//   return ((fnName = <conditional>), fnName(arg))
+function isBabelTypeofHelper(stmt) {
+    if (!t.isFunctionDeclaration(stmt) || !stmt.id || stmt.params.length !== 1)
+        return false;
+    const body = stmt.body.body;
+    if (body.length !== 1 || !t.isReturnStatement(body[0]))
+        return false;
+    const arg = body[0].argument;
+    if (!arg || !t.isSequenceExpression(arg))
+        return false;
+    const exprs = arg.expressions;
+    if (exprs.length !== 2)
+        return false;
+    const first = exprs[0];
+    return (t.isAssignmentExpression(first) &&
+        t.isIdentifier(first.left, { name: stmt.id.name }));
+}
+// Detect `_defineProperty` / `_toPropertyKey`+`_defineProperty` combos.
+// Shape: 3-param function whose body contains an Object.defineProperty call with
+//   { value, enumerable, configurable, writable } descriptor.
+function isBabelDefinePropertyHelper(stmt) {
+    if (!t.isFunctionDeclaration(stmt) || !stmt.id || stmt.params.length !== 3)
+        return false;
+    const bodyCode = stmt.body.body;
+    const hasDefProp = (node) => {
+        if (t.isCallExpression(node) &&
+            t.isMemberExpression(node.callee) &&
+            t.isIdentifier(node.callee.object, { name: "Object" }) &&
+            t.isIdentifier(node.callee.property, {
+                name: "defineProperty",
+            })) {
+            const args = node.arguments;
+            if (args.length >= 3 && t.isObjectExpression(args[2])) {
+                const props = args[2].properties;
+                const keys = props
+                    .filter((p) => t.isObjectProperty(p) && t.isIdentifier(p.key))
+                    .map((p) => p.key.name);
+                return keys.includes("enumerable") && keys.includes("configurable") && keys.includes("writable");
+            }
+        }
+        return false;
+    };
+    // Walk statements for the defineProperty call (may be nested in return/conditional)
+    const walk = (node) => {
+        if (hasDefProp(node))
+            return true;
+        for (const key of Object.keys(node)) {
+            const child = node[key];
+            if (!child || typeof child !== "object")
+                continue;
+            if (Array.isArray(child)) {
+                if (child.some((c) => c && typeof c === "object" && "type" in c && walk(c)))
+                    return true;
+            }
+            else if ("type" in child) {
+                if (walk(child))
+                    return true;
+            }
+        }
+        return false;
+    };
+    return bodyCode.some((s) => walk(s));
+}
+// Detect `_objectSpreadPropsHelper` / `_objectKeys`.
+// Shape: 2-param function whose first statement declares a variable via Object.keys(param0)
+//   and whose body references getOwnPropertySymbols.
+function isBabelObjectSpreadHelper(stmt) {
+    if (!t.isFunctionDeclaration(stmt) || !stmt.id || stmt.params.length !== 2)
+        return false;
+    const body = stmt.body.body;
+    if (body.length < 2)
+        return false;
+    // First statement: var t = Object.keys(e)
+    const first = body[0];
+    if (!t.isVariableDeclaration(first))
+        return false;
+    const firstIsObjectKeys = first.declarations.some((d) => {
+        if (!d.init || !t.isCallExpression(d.init))
+            return false;
+        const callee = d.init.callee;
+        return (t.isMemberExpression(callee) &&
+            t.isIdentifier(callee.object, { name: "Object" }) &&
+            t.isIdentifier(callee.property, { name: "keys" }));
+    });
+    if (!firstIsObjectKeys)
+        return false;
+    // Body references getOwnPropertySymbols
+    const bodyStr = JSON.stringify(body);
+    return bodyStr.includes('"getOwnPropertySymbols"');
+}
+// Detect `_objectSpread2` — Babel's 1-param spread helper that uses arguments.length
+// and Object.defineProperties to merge source objects into the target.
+function isBabelObjectSpread2Helper(stmt) {
+    if (!t.isFunctionDeclaration(stmt))
+        return false;
+    const params = stmt.params;
+    if (params.length !== 1)
+        return false;
+    const body = stmt.body.body;
+    // Must have a for loop that reads arguments.length, then calls Object.defineProperties
+    const hasArgumentsLength = JSON.stringify(body).includes('"arguments"');
+    const hasDefineProperties = JSON.stringify(body).includes('"defineProperties"') || JSON.stringify(body).includes('"defineProperty"');
+    return hasArgumentsLength && hasDefineProperties;
+}
+// Detect `_ownKeys` / `ownKeys` — companion helper to _objectSpread2.
+// Shape: 1- or 2-param function whose first statement declares a var via Object.keys(param)
+//   and whose body references getOwnPropertySymbols.
+function isBabelOwnKeysHelper(stmt) {
+    if (!t.isFunctionDeclaration(stmt))
+        return false;
+    const params = stmt.params;
+    if (params.length < 1 || params.length > 2)
+        return false;
+    const body = stmt.body.body;
+    if (body.length === 0)
+        return false;
+    // First statement declares a var via Object.keys(param)
+    const first = body[0];
+    if (!t.isVariableDeclaration(first))
+        return false;
+    const bodyStr = JSON.stringify(body);
+    return bodyStr.includes('"keys"') && bodyStr.includes('"getOwnPropertySymbols"');
+}
+// Named Babel array-destructure companion helpers that appear as FunctionDeclarations.
+const NAMED_BABEL_ARRAY_HELPERS = new Set([
+    "_arrayWithHoles",
+    "_arrayLikeToArray",
+    "_iterableToArrayLimit",
+    "_unsupportedIterableToArray",
+    "_nonIterableRest",
+]);
+function isNamedBabelArrayHelper(stmt) {
+    return t.isFunctionDeclaration(stmt) && stmt.id != null && NAMED_BABEL_ARRAY_HELPERS.has(stmt.id.name);
+}
+/** Remove `var x = {}` declarations where every declarator has an empty-object init.
+ *  These are webpack module-cache variables. */
+function dropEmptyObjectVars(stmts) {
+    return stmts.filter((stmt) => {
+        if (!t.isVariableDeclaration(stmt))
+            return true;
+        return !stmt.declarations.every((d) => d.init && t.isObjectExpression(d.init) && d.init.properties.length === 0);
+    });
+}
+// ---------------------------------------------------------------------------
+// Pass H — prune unused named imports (e.g. jsx/jsxs after JSX recovery)
+// ---------------------------------------------------------------------------
+/** Collect all free identifier references in the given statements. */
+function collectReferencedNames(stmts) {
+    const names = new Set();
+    const syntheticFile = t.file(t.program(stmts, [], "module"));
+    traverse(syntheticFile, {
+        Identifier(p) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            // Skip identifier nodes that are property names or binding declarations
+            if ((_a = p.parentPath) === null || _a === void 0 ? void 0 : _a.isImportSpecifier())
+                return;
+            if ((_b = p.parentPath) === null || _b === void 0 ? void 0 : _b.isImportDefaultSpecifier())
+                return;
+            if ((_c = p.parentPath) === null || _c === void 0 ? void 0 : _c.isImportNamespaceSpecifier())
+                return;
+            if (((_d = p.parentPath) === null || _d === void 0 ? void 0 : _d.isMemberExpression()) &&
+                !p.parent.computed &&
+                p.parentPath.get("property") === p)
+                return;
+            if (((_e = p.parentPath) === null || _e === void 0 ? void 0 : _e.isObjectProperty()) &&
+                !p.parent.computed &&
+                p.parentPath.get("key") === p)
+                return;
+            if ((_f = p.parentPath) === null || _f === void 0 ? void 0 : _f.isJSXAttribute())
+                return;
+            if (((_g = p.parentPath) === null || _g === void 0 ? void 0 : _g.isJSXOpeningElement()) || ((_h = p.parentPath) === null || _h === void 0 ? void 0 : _h.isJSXClosingElement()))
+                return;
+            names.add(p.node.name);
+        },
+        JSXIdentifier(p) {
+            // JSX element names (e.g. <Fragment>) are JSXIdentifier nodes, not Identifier.
+            // Add them so their import specifiers survive Pass H pruning.
+            names.add(p.node.name);
+        },
+    });
+    return names;
+}
+/** Remove named import specifiers whose local name is not referenced in `bodyStmts`. */
+function pruneUnusedNamedImports(importStmts, bodyStmts) {
+    const refs = collectReferencedNames(bodyStmts);
+    return importStmts
+        .map((stmt) => {
+        if (!t.isImportDeclaration(stmt))
+            return stmt;
+        const prunedSpecifiers = stmt.specifiers.filter((spec) => {
+            if (t.isImportNamespaceSpecifier(spec))
+                return true; // always keep namespace imports
+            if (t.isImportDefaultSpecifier(spec))
+                return true;
+            if (t.isImportSpecifier(spec)) {
+                const localName = t.isIdentifier(spec.local) ? spec.local.name : null;
+                return localName ? refs.has(localName) : true;
+            }
+            return true;
+        });
+        if (prunedSpecifiers.length === 0)
+            return null; // drop empty imports
+        if (prunedSpecifiers.length === stmt.specifiers.length)
+            return stmt; // unchanged
+        return t.importDeclaration(prunedSpecifiers, stmt.source);
+    })
+        .filter(Boolean);
+}
+// ---------------------------------------------------------------------------
+// Pass D for module files — library-aware import rewriting
+// ---------------------------------------------------------------------------
+/**
+ * Applies Pass D to an already-transformed module file whose imports are in the
+ * form `import * as ns from './N.js'`.  Looks up each module ID `N` in
+ * `libModuleMap`, rewrites call-sites from `(0, ns.hook)(...)` to `hook(...)`,
+ * replaces namespace imports with named imports from the real library path, and
+ * prunes unused specifiers.
+ *
+ * Returns the rewritten statement list (imports first, then body).
+ * If `libModuleMap` is empty / not provided, returns `statements` unchanged.
+ */
+export const applyLibraryImportRewriting = (statements, libModuleMap) => {
+    if (!libModuleMap || libModuleMap.size === 0)
+        return statements;
+    // Separate existing import declarations from body statements
+    const importDecls = [];
+    const bodyStmts = [];
+    for (const stmt of statements) {
+        if (t.isImportDeclaration(stmt))
+            importDecls.push(stmt);
+        else
+            bodyStmts.push(stmt);
+    }
+    // Build varName → moduleId from `import * as ns from './N.js'`
+    const varToModuleId = new Map(); // ns → numericModuleId
+    for (const decl of importDecls) {
+        const source = decl.source.value;
+        const match = source.match(/^\.\/(\d+)\.js$/);
+        if (!match)
+            continue;
+        const numId = parseInt(match[1], 10);
+        for (const spec of decl.specifiers) {
+            if (t.isImportNamespaceSpecifier(spec)) {
+                varToModuleId.set(spec.local.name, numId);
+            }
+        }
+    }
+    // Build varName → LibraryModuleInfo
+    const varToLib = new Map();
+    for (const [varName, numId] of varToModuleId) {
+        const info = libModuleMap.get(String(numId));
+        if (info)
+            varToLib.set(varName, info);
+    }
+    if (varToLib.size === 0)
+        return statements;
+    // --- CSS injection stripping ---
+    // Collect CSS-typed import vars (style-loader, css-module)
+    const cssImportVars = new Set();
+    for (const [varName, info] of varToLib) {
+        if (info.type === "style-loader" || info.type === "css-module") {
+            cssImportVars.add(varName);
+        }
+    }
+    if (cssImportVars.size > 0) {
+        const CSS_INJECT_PROPS = new Set([
+            "styleTagTransform",
+            "setAttributes",
+            "insert",
+            "domAPI",
+            "insertStyleElement",
+        ]);
+        // Find CSS wrapper vars: var x = <expr>.n(libVar) for any library import.
+        // webpack's .n() (interopRequireDefault) only appears in the CSS injection
+        // setup in React apps; it's safe to strip all library-import .n() wrappers.
+        const allLibVars = new Set(varToLib.keys());
+        const cssWrapperVars = new Set();
+        for (const stmt of bodyStmts) {
+            if (!t.isVariableDeclaration(stmt))
+                continue;
+            for (const decl of stmt.declarations) {
+                if (!t.isIdentifier(decl.id) || !decl.init)
+                    continue;
+                if (!t.isCallExpression(decl.init))
+                    continue;
+                const callee = decl.init.callee;
+                const args = decl.init.arguments;
+                if (t.isMemberExpression(callee) &&
+                    !callee.computed &&
+                    t.isIdentifier(callee.property, { name: "n" }) &&
+                    args.length === 1 &&
+                    t.isIdentifier(args[0]) &&
+                    allLibVars.has(args[0].name)) {
+                    cssWrapperVars.add(decl.id.name);
+                }
+            }
+        }
+        // Find CSS config object vars: var g = {} where g is assigned CSS injection props
+        const cssConfigObjVars = new Set();
+        for (const stmt of bodyStmts) {
+            if (!t.isExpressionStatement(stmt))
+                continue;
+            const expr = stmt.expression;
+            if (!t.isAssignmentExpression(expr))
+                continue;
+            const lhs = expr.left;
+            if (!t.isMemberExpression(lhs) || lhs.computed)
+                continue;
+            const prop = lhs.property;
+            if (t.isIdentifier(prop) && CSS_INJECT_PROPS.has(prop.name)) {
+                if (t.isIdentifier(lhs.object))
+                    cssConfigObjVars.add(lhs.object.name);
+            }
+        }
+        const isCssMemberRef = (e) => {
+            if (!t.isMemberExpression(e) || e.computed)
+                return false;
+            return (t.isIdentifier(e.object) &&
+                cssImportVars.has(e.object.name));
+        };
+        const hasLogicalCssRef = (e) => {
+            if (isCssMemberRef(e))
+                return true;
+            if (t.isLogicalExpression(e))
+                return (hasLogicalCssRef(e.left) ||
+                    hasLogicalCssRef(e.right));
+            return false;
+        };
+        const isCssInjectionStmt = (stmt) => {
+            if (!t.isExpressionStatement(stmt))
+                return false;
+            const expr = stmt.expression;
+            // g.styleTagTransform = ..., g.setAttributes = ..., etc.
+            if (t.isAssignmentExpression(expr) &&
+                t.isMemberExpression(expr.left) &&
+                !expr.left.computed &&
+                t.isIdentifier(expr.left.property) &&
+                CSS_INJECT_PROPS.has(expr.left.property.name))
+                return true;
+            // cssWrapperVar()(cssModuleVar.A, configObj)
+            if (t.isCallExpression(expr) && t.isCallExpression(expr.callee)) {
+                const innerCallee = expr.callee.callee;
+                if (t.isIdentifier(innerCallee) && cssWrapperVars.has(innerCallee.name))
+                    return true;
+            }
+            // cssModuleVar.A && cssModuleVar.A.locals && cssModuleVar.A.locals
+            if (t.isLogicalExpression(expr) && hasLogicalCssRef(expr))
+                return true;
+            return false;
+        };
+        const filteredStmts = [];
+        for (const stmt of bodyStmts) {
+            if (isCssInjectionStmt(stmt))
+                continue;
+            if (t.isVariableDeclaration(stmt)) {
+                const remaining = stmt.declarations.filter((decl) => {
+                    if (!t.isIdentifier(decl.id))
+                        return true;
+                    const name = decl.id.name;
+                    if (cssWrapperVars.has(name))
+                        return false;
+                    if (cssConfigObjVars.has(name) &&
+                        decl.init &&
+                        t.isObjectExpression(decl.init) &&
+                        decl.init.properties.length === 0)
+                        return false;
+                    return true;
+                });
+                if (remaining.length === 0)
+                    continue;
+                filteredStmts.push(remaining.length < stmt.declarations.length ? t.variableDeclaration(stmt.kind, remaining) : stmt);
+                continue;
+            }
+            filteredStmts.push(stmt);
+        }
+        bodyStmts.splice(0, bodyStmts.length, ...filteredStmts);
+    }
+    // Rewrite call-sites in bodyStmts; collect used exports per library
+    const usedExports = rewriteLibraryCalls(bodyStmts, varToLib);
+    // Build replacement import declarations
+    const finalImportStmts = [];
+    const handledSpecs = new Set();
+    for (const [varName, info] of varToLib) {
+        const src = librarySource(info.type);
+        if (!src)
+            continue;
+        if (!handledSpecs.has(src)) {
+            handledSpecs.add(src);
+            const used = usedExports.get(src);
+            if (used && used.size > 0) {
+                const specifiers = [...used]
+                    .sort()
+                    .map((name) => t.importSpecifier(t.identifier(name), t.identifier(name)));
+                finalImportStmts.push(t.importDeclaration(specifiers, t.stringLiteral(src)));
+            }
+        }
+    }
+    // Keep non-library namespace imports unchanged.
+    // For library namespace imports: keep only if the namespace variable is still used as
+    // the object of a MemberExpression or JSXMemberExpression (i.e., namespace access).
+    // Using collectReferencedNames would falsely keep imports when a local variable in a
+    // closure happens to share the namespace name (e.g. `const n = e.toLowerCase()`).
+    const namespaceObjRefs = new Set();
+    {
+        const syntheticFile = t.file(t.program(bodyStmts, [], "module"));
+        traverse(syntheticFile, {
+            MemberExpression(p) {
+                if (!p.node.computed && t.isIdentifier(p.node.object)) {
+                    namespaceObjRefs.add(p.node.object.name);
+                }
+            },
+            JSXMemberExpression(p) {
+                if (t.isJSXIdentifier(p.node.object)) {
+                    namespaceObjRefs.add(p.node.object.name);
+                }
+            },
+        });
+    }
+    for (const decl of importDecls) {
+        const source = decl.source.value;
+        const match = source.match(/^\.\/(\d+)\.js$/);
+        if (!match) {
+            finalImportStmts.push(decl);
+            continue;
+        }
+        const numId = parseInt(match[1], 10);
+        const isLibrary = [...varToModuleId.entries()].some(([vn, id]) => id === numId && varToLib.has(vn));
+        if (!isLibrary) {
+            finalImportStmts.push(decl);
+            continue;
+        }
+        // Library module: keep the namespace import only if the namespace var is
+        // still used as a namespace object (i.e. some exports were not resolved).
+        const hasRemainingRefs = decl.specifiers.some((spec) => t.isImportNamespaceSpecifier(spec) && namespaceObjRefs.has(spec.local.name));
+        if (hasRemainingRefs)
+            finalImportStmts.push(decl);
+    }
+    // Pass H — prune named imports that are no longer referenced
+    const prunedImports = pruneUnusedNamedImports(finalImportStmts, bodyStmts);
+    return [...prunedImports, ...bodyStmts];
+};
+// ---------------------------------------------------------------------------
+// Module cleanup passes — applies E/F/G standalone (no webpack require context needed)
+// ---------------------------------------------------------------------------
+/**
+ * Applies JSX recovery, slicedToArray collapse, and Babel helper removal to
+ * any list of statements.  Used for both individual module files and index.js.
+ * Does NOT require a webpack require-function name or library module map.
+ */
+export const applyModuleCleanupPasses = (statements) => {
+    // Pass E — collapse Babel slicedToArray expansions.
+    const afterE = collapseSlicedToArrayDeep(statements);
+    // Pass F — JSX recovery.
+    recoverJSX(afterE);
+    // Pass G — remove top-level Babel helper functions and webpack module-cache vars.
+    const afterG = dropEmptyObjectVars(afterE.filter((stmt) => !isBabelArrayLikeToArrayHelper(stmt) &&
+        !isBabelTypeofHelper(stmt) &&
+        !isBabelDefinePropertyHelper(stmt) &&
+        !isBabelObjectSpreadHelper(stmt) &&
+        !isBabelObjectSpread2Helper(stmt) &&
+        !isBabelOwnKeysHelper(stmt) &&
+        !isNamedBabelArrayHelper(stmt)));
+    return afterG;
+};
+// ---------------------------------------------------------------------------
+// Route-aware component renaming
+// ---------------------------------------------------------------------------
+/** Derives a component name from a React Router path string. */
+function pathToComponentName(fullPath) {
+    if (fullPath === "/" || fullPath === "")
+        return "Home";
+    const isIndex = fullPath.endsWith("/index");
+    const base = isIndex ? fullPath.slice(0, -"/index".length) : fullPath;
+    const segments = base
+        .replace(/^\//, "")
+        .split("/")
+        .filter((s) => s && !s.startsWith(":"));
+    if (segments.length === 0)
+        return "Home";
+    const name = segments
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1).replace(/-(\w)/g, (_, c) => c.toUpperCase()))
+        .join("");
+    return isIndex ? `${name}Dashboard` : name;
+}
+/**
+ * Post-pass that renames minified component variables to meaningful names derived
+ * from React Router route paths. Intended to run after JSX recovery (Pass F) so
+ * that `<Route path="..." element={<X />} />` patterns are visible as JSX.
+ *
+ * Also renames:
+ *   - The root App component (the one that contains `<Routes>`)
+ *   - The Suspense fallback component (if it's a locally-defined function)
+ */
+export const renameRouteComponents = (statements) => {
+    // Step 1: collect lazy-import variable names → spec (e.g. '_' → './45.js')
+    const lazyVars = new Map(); // varName → importSpec
+    for (const stmt of statements) {
+        if (!t.isVariableDeclaration(stmt))
+            continue;
+        for (const decl of stmt.declarations) {
+            if (!t.isIdentifier(decl.id) || !decl.init)
+                continue;
+            if (!t.isCallExpression(decl.init))
+                continue;
+            const callExpr = decl.init;
+            if (!t.isIdentifier(callExpr.callee, { name: "lazy" }))
+                continue;
+            if (callExpr.arguments.length !== 1)
+                continue;
+            const arg = callExpr.arguments[0];
+            if (!t.isArrowFunctionExpression(arg) && !t.isFunctionExpression(arg))
+                continue;
+            const body = arg.body;
+            // body is `import('./N.js')` — a CallExpression with an Import callee
+            const importCall = t.isBlockStatement(body)
+                ? body.body.length === 1 &&
+                    t.isReturnStatement(body.body[0])
+                    ? body.body[0].argument
+                    : null
+                : body;
+            if (!importCall || !t.isCallExpression(importCall))
+                continue;
+            if (!t.isImport(importCall.callee))
+                continue;
+            const importArgs = importCall.arguments;
+            if (importArgs.length !== 1 || !t.isStringLiteral(importArgs[0]))
+                continue;
+            lazyVars.set(decl.id.name, importArgs[0].value);
+        }
+    }
+    if (lazyVars.size === 0)
+        return statements;
+    // Step 2: traverse JSX Route elements, tracking parent route paths for full-path assembly.
+    const varToPath = new Map(); // varName → full route path
+    const syntheticFile = t.file(t.program(statements, [], "module"));
+    const pathStack = [];
+    traverse(syntheticFile, {
+        JSXElement: {
+            enter(p) {
+                const opening = p.node.openingElement;
+                if (!t.isJSXIdentifier(opening.name, { name: "Route" }))
+                    return;
+                let routePath = null;
+                let isIndex = false;
+                let elementVarName = null;
+                for (const attr of opening.attributes) {
+                    if (!t.isJSXAttribute(attr))
+                        continue;
+                    const keyName = t.isJSXIdentifier(attr.name) ? attr.name.name : null;
+                    if (keyName === "path" && t.isStringLiteral(attr.value)) {
+                        routePath = attr.value.value;
+                    }
+                    else if (keyName === "index") {
+                        isIndex = true;
+                    }
+                    else if (keyName === "element") {
+                        const val = attr.value;
+                        const jsxEl = t.isJSXExpressionContainer(val)
+                            ? t.isJSXElement(val.expression)
+                                ? val.expression
+                                : null
+                            : t.isJSXElement(val)
+                                ? val
+                                : null;
+                        if (jsxEl) {
+                            const tagName = jsxEl.openingElement.name;
+                            if (t.isJSXIdentifier(tagName))
+                                elementVarName = tagName.name;
+                        }
+                    }
+                }
+                const parentPath = pathStack.length > 0 ? pathStack[pathStack.length - 1] : "";
+                let fullPath;
+                if (routePath !== null) {
+                    fullPath = routePath.startsWith("/") ? routePath : `${parentPath}/${routePath}`;
+                }
+                else if (isIndex) {
+                    fullPath = `${parentPath}/index`;
+                }
+                else {
+                    fullPath = parentPath;
+                }
+                pathStack.push(fullPath);
+                if (elementVarName && lazyVars.has(elementVarName)) {
+                    varToPath.set(elementVarName, fullPath);
+                }
+            },
+            exit(p) {
+                if (t.isJSXIdentifier(p.node.openingElement.name, { name: "Route" })) {
+                    pathStack.pop();
+                }
+            },
+        },
+    });
+    // Step 3: generate semantic names from route paths
+    const renames = new Map(); // oldName → newName
+    const usedNames = new Set();
+    for (const [varName, fullPath] of varToPath) {
+        let name = pathToComponentName(fullPath);
+        if (usedNames.has(name)) {
+            let i = 2;
+            while (usedNames.has(`${name}${i}`))
+                i++;
+            name = `${name}${i}`;
+        }
+        usedNames.add(name);
+        renames.set(varName, name);
+    }
+    // Step 4: find the root App component — the function whose JSX body contains <Routes>
+    traverse(syntheticFile, {
+        JSXElement(p) {
+            if (!t.isJSXIdentifier(p.node.openingElement.name, { name: "Routes" }))
+                return;
+            let ancestor = p.parentPath;
+            while (ancestor) {
+                if (ancestor.isFunctionDeclaration() ||
+                    ancestor.isFunctionExpression() ||
+                    ancestor.isArrowFunctionExpression()) {
+                    if (ancestor.isFunctionDeclaration()) {
+                        const id = ancestor.node.id;
+                        if (id && !renames.has(id.name))
+                            renames.set(id.name, "App");
+                    }
+                    else {
+                        const par = ancestor.parentPath;
+                        if (par === null || par === void 0 ? void 0 : par.isVariableDeclarator()) {
+                            const declId = par.node.id;
+                            if (t.isIdentifier(declId) && !renames.has(declId.name)) {
+                                renames.set(declId.name, "App");
+                            }
+                        }
+                    }
+                    break;
+                }
+                if (!ancestor.parentPath)
+                    break;
+                ancestor = ancestor.parentPath;
+            }
+            p.skip();
+        },
+    });
+    // Step 5: find the Suspense fallback component
+    traverse(syntheticFile, {
+        JSXAttribute(p) {
+            if (!t.isJSXIdentifier(p.node.name, { name: "fallback" }))
+                return;
+            const val = p.node.value;
+            if (!t.isJSXExpressionContainer(val))
+                return;
+            const expr = val.expression;
+            if (!t.isJSXElement(expr))
+                return;
+            const tagName = expr.openingElement.name;
+            if (!t.isJSXIdentifier(tagName))
+                return;
+            const varName = tagName.name;
+            if (!renames.has(varName) && !lazyVars.has(varName)) {
+                renames.set(varName, "Loading");
+            }
+        },
+    });
+    if (renames.size === 0)
+        return statements;
+    // Step 6: rename bindings via scope analysis, then patch any remaining JSXIdentifiers
+    traverse(syntheticFile, {
+        Program(p) {
+            for (const [oldName, newName] of renames) {
+                if (p.scope.hasBinding(oldName)) {
+                    p.scope.rename(oldName, newName);
+                }
+            }
+        },
+    });
+    // JSXIdentifier nodes may not be tracked by scope — patch them explicitly as a fallback
+    traverse(syntheticFile, {
+        JSXIdentifier(p) {
+            const newName = renames.get(p.node.name);
+            if (newName)
+                p.node.name = newName;
+        },
+    });
+    return statements;
+};
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+/**
+ * Transforms the non-module-map IIFE statements that become `index.js`.
+ *
+ * Passes:
+ *   A – Remove webpack require helper function.
+ *   B – Hoist top-level `var x = requireFn(N)` to static `import * as x from "./N.js"`.
+ *   C – Replace remaining inline `requireFn(N)` calls.
+ *   D – Rewrite library module calls using identity map (e.g. `l.H(...)` → `createRoot(...)`)
+ *       and replace namespace imports with named imports from proper library paths.
+ *   E – Collapse Babel slicedToArray expansions to `const [a, b] = expr`.
+ *   F – Recover JSX from `jsx(tag, props)` / `jsxs(tag, props)` calls.
+ *   G – Remove Babel array-helper functions (e.g. `arrayLikeToArray`).
+ */
+export const transformIndexStatements = (statements, libModuleMap) => {
+    // Pass A — detect and remove webpack require helper(s).
+    const requireFnNames = new Set();
+    const afterA = [];
+    for (const stmt of statements) {
+        if (t.isFunctionDeclaration(stmt) && stmt.id && isWebpackRequireHelper(stmt)) {
+            requireFnNames.add(stmt.id.name);
+            continue; // drop
+        }
+        afterA.push(stmt);
+    }
+    if (requireFnNames.size === 0)
+        return statements; // nothing to do
+    // Pass A.1 — strip webpack runtime bootstrap statements.
+    // Any statement that references requireFn.X (assignments, calls, or var inits)
+    // is webpack infrastructure.  Also strip the runtime temp-var declarations that
+    // have no init / empty-collection init and 3+ declarators.
+    const containsRequireFnMember = (node, fnName) => {
+        if (t.isMemberExpression(node) && t.isIdentifier(node.object, { name: fnName }))
+            return true;
+        for (const key of Object.keys(node)) {
+            const child = node[key];
+            if (child && typeof child === "object") {
+                if (Array.isArray(child)) {
+                    for (const item of child) {
+                        if (item &&
+                            typeof item.type === "string" &&
+                            containsRequireFnMember(item, fnName))
+                            return true;
+                    }
+                }
+                else if (typeof child.type === "string") {
+                    if (containsRequireFnMember(child, fnName))
+                        return true;
+                }
+            }
+        }
+        return false;
+    };
+    const isRuntimeTempVarDecl = (stmt) => {
+        if (!t.isVariableDeclaration(stmt) || stmt.declarations.length < 3)
+            return false;
+        return stmt.declarations.every((decl) => {
+            if (!decl.init)
+                return true;
+            if (t.isObjectExpression(decl.init) && decl.init.properties.length === 0)
+                return true;
+            if (t.isArrayExpression(decl.init) && decl.init.elements.length === 0)
+                return true;
+            if (t.isUnaryExpression(decl.init) && decl.init.operator === "void")
+                return true;
+            return false;
+        });
+    };
+    const afterA1 = [];
+    for (const stmt of afterA) {
+        let isRuntime = isRuntimeTempVarDecl(stmt);
+        if (!isRuntime) {
+            for (const fnName of requireFnNames) {
+                if (containsRequireFnMember(stmt, fnName)) {
+                    isRuntime = true;
+                    break;
+                }
+            }
+        }
+        if (!isRuntime)
+            afterA1.push(stmt);
+    }
+    const hoistedImports = new Map();
+    const importNameByNumId = new Map();
+    // Pass B — hoist top-level `var x = requireFn(N)` to static imports.
+    // Also build varName → moduleId so Pass D can look up library identity.
+    const varToModuleId = new Map(); // localVarName → numericModuleId
+    const afterB = [];
+    for (const stmt of afterA1) {
+        if (!t.isVariableDeclaration(stmt)) {
+            afterB.push(stmt);
+            continue;
+        }
+        const kept = [];
+        for (const decl of stmt.declarations) {
+            if (!t.isIdentifier(decl.id) || !decl.init) {
+                kept.push(decl);
+                continue;
+            }
+            let matched = false;
+            for (const fnName of requireFnNames) {
+                const numId = tryExtractRequireCall(decl.init, fnName);
+                if (numId === null)
+                    continue;
+                const spec = `./${numId}.js`;
+                const localName = decl.id.name;
+                if (!hoistedImports.has(spec)) {
+                    hoistedImports.set(spec, localName);
+                    importNameByNumId.set(numId, localName);
+                }
+                varToModuleId.set(localName, numId);
+                matched = true;
+                break;
+            }
+            if (!matched)
+                kept.push(decl);
+        }
+        if (kept.length > 0)
+            afterB.push(t.variableDeclaration(stmt.kind, kept));
+    }
+    // Pass C — replace remaining inline requireFn(N) calls recursively.
+    const syntheticFile = t.file(t.program(afterB, [], "module"));
+    traverse(syntheticFile, {
+        CallExpression(p) {
+            for (const fnName of requireFnNames) {
+                const numId = tryExtractRequireCall(p.node, fnName);
+                if (numId === null)
+                    continue;
+                let name = importNameByNumId.get(numId);
+                if (!name) {
+                    name = `_jsr_module_${numId}`;
+                    hoistedImports.set(`./${numId}.js`, name);
+                    importNameByNumId.set(numId, name);
+                }
+                p.replaceWith(t.identifier(name));
+                p.skip();
+                break;
+            }
+        },
+    });
+    // Pass D — library-aware import rewriting (only when libModuleMap is supplied).
+    // Build varName → LibraryModuleInfo, then rewrite calls and imports.
+    const finalImportStmts = [];
+    if (libModuleMap && libModuleMap.size > 0) {
+        // Map local var names to their library identity
+        const varToLib = new Map();
+        for (const [varName, numId] of varToModuleId) {
+            const info = libModuleMap.get(String(numId));
+            if (info)
+                varToLib.set(varName, info);
+        }
+        if (varToLib.size > 0) {
+            // Rewrite call-sites; collect which named exports are actually used
+            const usedExports = rewriteLibraryCalls(afterB, varToLib);
+            // Build import declarations for library modules (named imports).
+            // handledSpecs guards only the import-declaration emit (avoid duplicates when
+            // two local vars map to the same library source). The namespace-import deletion
+            // must happen for EVERY var that maps to a library, regardless of dedup.
+            const handledSpecs = new Set();
+            for (const [varName, info] of varToLib) {
+                const src = librarySource(info.type);
+                if (!src)
+                    continue;
+                if (!handledSpecs.has(src)) {
+                    handledSpecs.add(src);
+                    const used = usedExports.get(src);
+                    if (used && used.size > 0) {
+                        const specifiers = [...used]
+                            .sort()
+                            .map((name) => t.importSpecifier(t.identifier(name), t.identifier(name)));
+                        finalImportStmts.push(t.importDeclaration(specifiers, t.stringLiteral(src)));
+                    }
+                }
+                // Always remove the namespace import for this var, even if src was already handled.
+                const numId = varToModuleId.get(varName);
+                if (numId !== undefined)
+                    hoistedImports.delete(`./${numId}.js`);
+            }
+        }
+    }
+    // Remaining (non-library) namespace imports
+    for (const [spec, name] of hoistedImports) {
+        finalImportStmts.push(t.importDeclaration([t.importNamespaceSpecifier(t.identifier(name))], t.stringLiteral(spec)));
+    }
+    // Pass E — collapse Babel slicedToArray expansions.
+    const afterE = collapseSlicedToArrayDeep(afterB);
+    // Pass F — JSX recovery.
+    recoverJSX(afterE);
+    // Pass G — remove top-level Babel helper functions and webpack module-cache vars.
+    const afterG = dropEmptyObjectVars(afterE.filter((stmt) => !isBabelArrayLikeToArrayHelper(stmt) &&
+        !isBabelTypeofHelper(stmt) &&
+        !isBabelDefinePropertyHelper(stmt) &&
+        !isBabelObjectSpreadHelper(stmt) &&
+        !isBabelObjectSpread2Helper(stmt) &&
+        !isBabelOwnKeysHelper(stmt) &&
+        !isNamedBabelArrayHelper(stmt)));
+    // Pass H — prune named imports whose local name is no longer referenced
+    //           (e.g. jsx/jsxs after JSX recovery, namespace imports that were cleared).
+    const prunedImports = pruneUnusedNamedImports(finalImportStmts, afterG);
+    return [...prunedImports, ...afterG];
+};
+//# sourceMappingURL=transform.js.map