@shriyanss/js-recon 1.3.1-beta.2 → 1.4.1-alpha.1

package/build/refactor/react/transform.js

@@ -0,0 +1,839 @@
+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";
+const traverse = _traverse.default;
+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 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();
+            },
+        });
+    }
+    // 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);
+        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();
+        },
+    });
+    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;
+}
+/** 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
+    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) {
+    if (t.isStringLiteral(expr))
+        return t.jsxIdentifier(expr.value);
+    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) {
+    if (t.isStringLiteral(child))
+        return t.jsxText(child.value);
+    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);
+}
+function tryConvertToJSX(call) {
+    const callee = call.callee;
+    if (!t.isIdentifier(callee))
+        return null;
+    if (callee.name !== "jsx" && callee.name !== "jsxs" && callee.name !== "jsxDEV")
+        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 = [];
+    const children = [];
+    if (t.isObjectExpression(propsArg)) {
+        for (const prop of propsArg.properties) {
+            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") {
+                // 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);
+                    }
+                }
+                else {
+                    const ch = childToJsxChild(valNode);
+                    if (ch)
+                        children.push(ch);
+                }
+                continue;
+            }
+            // Normal prop
+            const attrName = t.jsxIdentifier(keyName);
+            if (t.isJSXExpressionContainer(valNode) || t.isStringLiteral(valNode)) {
+                attrs.push(t.jsxAttribute(attrName, exprToJsxAttrValue(valNode)));
+            }
+            else {
+                attrs.push(t.jsxAttribute(attrName, exprToJsxAttrValue(valNode)));
+            }
+        }
+    }
+    const selfClosing = children.length === 0;
+    const openingElement = t.jsxOpeningElement(jsxName, attrs, 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);
+            p.skip();
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// 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"');
+}
+/** 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);
+}
+// ---------------------------------------------------------------------------
+// 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
+    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) {
+        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)));
+    // 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