@shriyanss/js-recon 1.4.1-alpha.2 → 1.4.1-alpha.3

package/build/refactor/react/transform.js

@@ -2,7 +2,7 @@ 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, librarySource, } from "./library-classify.js";
+import { REACT_CANONICAL, JSX_RUNTIME_CANONICAL, REACT_DOM_CLIENT_CANONICAL, REACT_ROUTER_DOM_CANONICAL, librarySource, } from "./library-classify.js";
 const traverse = _traverse.default;
 const generate = _generator.default;
 /**
@@ -55,6 +55,92 @@ export const transformModule = (mod) => {
         }
         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 = [];
@@ -142,6 +228,58 @@ export const transformModule = (mod) => {
             },
         });
     }
+    // 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) {
@@ -194,6 +332,8 @@ function resolveLibraryProp(varName, prop, varToLib) {
             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.
@@ -281,6 +421,36 @@ function rewriteLibraryCalls(statements, varToLib) {
             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;
 }
@@ -384,11 +554,174 @@ function collapseSlicedToArray(statements) {
     }
     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 top-level
-    const top = collapseSlicedToArray(statements);
-    // Then recurse into function bodies via a traverse
+    // 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) {
@@ -404,8 +737,15 @@ function collapseSlicedToArrayDeep(statements) {
 // 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)) {
@@ -421,8 +761,15 @@ function exprToJsxAttrValue(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.
@@ -433,23 +780,52 @@ function childToJsxChild(child) {
     }
     return t.jsxExpressionContainer(child);
 }
-function tryConvertToJSX(call) {
-    const callee = call.callee;
-    if (!t.isIdentifier(callee))
+// 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;
-    if (callee.name !== "jsx" && callee.name !== "jsxs" && callee.name !== "jsxDEV")
+    const callee = expr.callee;
+    if (!t.isFunctionExpression(callee))
         return null;
-    if (call.arguments.length < 2)
+    if (callee.params.length !== 1 || !t.isIdentifier(callee.params[0]))
         return null;
-    const tagArg = call.arguments[0];
-    const propsArg = call.arguments[1];
-    const jsxName = exprToJsxName(tagArg);
-    if (!jsxName)
+    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 children = [];
-    if (t.isObjectExpression(propsArg)) {
-        for (const prop of propsArg.properties) {
+    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;
@@ -458,35 +834,94 @@ function tryConvertToJSX(call) {
             if (!keyName)
                 continue;
             if (keyName === "children") {
-                // children can be a single value or an array
                 if (t.isArrayExpression(valNode)) {
                     for (const el of valNode.elements) {
-                        if (!el)
-                            continue;
-                        const ch = childToJsxChild(el);
-                        if (ch)
-                            children.push(ch);
+                        if (el)
+                            childExprs.push(el);
                     }
                 }
                 else {
-                    const ch = childToJsxChild(valNode);
-                    if (ch)
-                        children.push(ch);
+                    childExprs.push(valNode);
                 }
                 continue;
             }
-            // Normal prop
-            const attrName = t.jsxIdentifier(keyName);
-            if (t.isJSXExpressionContainer(valNode) || t.isStringLiteral(valNode)) {
-                attrs.push(t.jsxAttribute(attrName, exprToJsxAttrValue(valNode)));
+            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.jsxAttribute(attrName, exprToJsxAttrValue(valNode)));
+                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, attrs, selfClosing);
+    const openingElement = t.jsxOpeningElement(jsxName, jsxAttrs, selfClosing);
     const closingElement = selfClosing ? null : t.jsxClosingElement(jsxName);
     return t.jsxElement(openingElement, closingElement, children, selfClosing);
 }
@@ -499,7 +934,7 @@ function recoverJSX(statements) {
             if (!jsxEl)
                 return;
             p.replaceWith(jsxEl);
-            p.skip();
+            // Do NOT skip — nested jsx calls inside lambdas/expression containers need visiting.
         },
     });
 }
@@ -617,6 +1052,50 @@ function isBabelObjectSpreadHelper(stmt) {
     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) {
@@ -692,6 +1171,481 @@ function pruneUnusedNamedImports(importStmts, bodyStmts) {
         .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
 // ---------------------------------------------------------------------------
 /**
@@ -720,13 +1674,68 @@ export const transformIndexStatements = (statements, libModuleMap) => {
     }
     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 afterA) {
+    for (const stmt of afterA1) {
         if (!t.isVariableDeclaration(stmt)) {
             afterB.push(stmt);
             continue;
@@ -830,7 +1839,10 @@ export const transformIndexStatements = (statements, libModuleMap) => {
     const afterG = dropEmptyObjectVars(afterE.filter((stmt) => !isBabelArrayLikeToArrayHelper(stmt) &&
         !isBabelTypeofHelper(stmt) &&
         !isBabelDefinePropertyHelper(stmt) &&
-        !isBabelObjectSpreadHelper(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);