@shriyanss/js-recon 1.4.1-alpha.4 → 1.4.1-alpha.5

package/build/refactor/next/transform.js

@@ -1,31 +1,674 @@
+var _a;
 import _traverse from "@babel/traverse";
+import _generator from "@babel/generator";
 import * as t from "@babel/types";
-import { tryExtractTurbopackRequire, tryExtractDefinePropertyExport, isEsModuleMarker, isInteropBoilerplate, tryExtractForInExportLoop, extractExportsFromMap, makeExportStatement, } from "./helpers.js";
-const traverse = _traverse.default;
+import { tryExtractTurbopackRequire, tryExtractWebpackRequire, tryExtractRuntimeSExport, tryExtractDefinePropertyExport, tryExtractBatchIIFEExports, tryExtractRequireDotD, isRequireDotR, isEsModuleMarker, isInteropBoilerplate, tryExtractModuleExportsRhs, tryExtractForInExportLoop, extractExportsFromMap, makeExportStatement, } from "./helpers.js";
+const traverse = ((_a = _traverse.default) !== null && _a !== void 0 ? _a : _traverse);
+const generate = _generator.default;
+// ---------------------------------------------------------------------------
+// Pass F — JSX recovery
+// ---------------------------------------------------------------------------
+function exprToJsxName(expr) {
+    var _a;
+    if (t.isStringLiteral(expr))
+        return t.jsxIdentifier(expr.value);
+    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);
+    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;
+    if (t.isCallExpression(child)) {
+        const converted = tryConvertToJSX(child);
+        if (converted)
+            return converted;
+    }
+    return t.jsxExpressionContainer(child);
+}
+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;
+    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;
+    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) };
+}
+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 {
+        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 {
+            attrs.push(t.jsxSpreadAttribute(propsArg));
+        }
+    }
+    return { attrs, childExprs };
+}
+const JSX_METHOD_NAMES = new Set(["jsx", "jsxs", "jsxDEV"]);
+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;
+        }
+    }
+    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);
+    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);
+}
+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);
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Pass E — Babel slicedToArray collapse
+// ---------------------------------------------------------------------------
+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;
+}
+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;
+        if (!t.isAssignmentExpression(exprs[0]) || exprs[0].operator !== "=")
+            continue;
+        const firstAssign = exprs[0];
+        if (!t.isIdentifier(firstAssign.left))
+            continue;
+        if (!t.isAssignmentExpression(exprs[1]) || !t.isNumericLiteral(exprs[1].right))
+            continue;
+        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;
+}
+function collapseSlicedToArray(statements) {
+    const out = [];
+    for (const stmt of statements) {
+        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;
+        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;
+}
+function isNamedSlicedToArrayHelper(stmt) {
+    if (!t.isFunctionDeclaration(stmt) || !stmt.id || stmt.params.length !== 2)
+        return null;
+    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;
+    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;
+}
+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 (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();
+            }
+            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;
+}
+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;
+    const withoutHelpers = statements.filter((s) => !(t.isFunctionDeclaration(s) && s.id && helperNames.has(s.id.name)));
+    const topCollapsed = collapseSlicedToArrayCalls(withoutHelpers, helperNames);
+    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;
+        },
+        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;
+}
+function collapseSlicedToArrayDeep(statements) {
+    const afterNamed = collapseNamedSlicedToArray(statements);
+    const top = collapseSlicedToArray(afterNamed);
+    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 G — remove Babel helpers
+// ---------------------------------------------------------------------------
+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;
+    return 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" }));
+    });
+}
+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 }));
+}
+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;
+    };
+    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));
+}
+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;
+    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;
+    return JSON.stringify(body).includes('"getOwnPropertySymbols"');
+}
+function isBabelObjectSpread2Helper(stmt) {
+    if (!t.isFunctionDeclaration(stmt))
+        return false;
+    if (stmt.params.length !== 1)
+        return false;
+    const body = stmt.body.body;
+    const hasArgumentsLength = JSON.stringify(body).includes('"arguments"');
+    const hasDefineProperties = JSON.stringify(body).includes('"defineProperties"') || JSON.stringify(body).includes('"defineProperty"');
+    return hasArgumentsLength && hasDefineProperties;
+}
+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;
+    const first = body[0];
+    if (!t.isVariableDeclaration(first))
+        return false;
+    const bodyStr = JSON.stringify(body);
+    return bodyStr.includes('"keys"') && bodyStr.includes('"getOwnPropertySymbols"');
+}
+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);
+}
+function removeBabelHelpers(stmts) {
+    return stmts.filter((s) => !isBabelArrayLikeToArrayHelper(s) &&
+        !isBabelTypeofHelper(s) &&
+        !isBabelDefinePropertyHelper(s) &&
+        !isBabelObjectSpreadHelper(s) &&
+        !isBabelObjectSpread2Helper(s) &&
+        !isBabelOwnKeysHelper(s) &&
+        !isNamedBabelArrayHelper(s));
+}
+// ---------------------------------------------------------------------------
+// Pass H — prune unused named imports
+// ---------------------------------------------------------------------------
+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;
+            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) {
+            names.add(p.node.name);
+        },
+    });
+    return names;
+}
+function pruneUnusedNamedImports(importStmts, bodyStmts) {
+    const refs = collectReferencedNames(bodyStmts);
+    return importStmts
+        .map((stmt) => {
+        if (!t.isImportDeclaration(stmt))
+            return stmt;
+        // Side-effect imports (no specifiers) are always kept.
+        if (stmt.specifiers.length === 0)
+            return stmt;
+        const prunedSpecifiers = stmt.specifiers.filter((spec) => {
+            if (t.isImportNamespaceSpecifier(spec))
+                return true;
+            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;
+        if (prunedSpecifiers.length === stmt.specifiers.length)
+            return stmt;
+        return t.importDeclaration(prunedSpecifiers, stmt.source);
+    })
+        .filter(Boolean);
+}
+// ---------------------------------------------------------------------------
+// Core transform: turbopack module format
+// ---------------------------------------------------------------------------
 /**
- * Transforms a single Turbopack module arrow function into ECMAScript module statements.
+ * Transforms a single Turbopack (or webpack-style) module arrow function into ECMAScript statements.
  *
- * Passes (top-level only to avoid placing exports inside nested functions):
- *   1. Collect exports from Object.defineProperty(exportsParam, …) patterns + mark nodes for removal.
- *   2. Combined filter + hoist: skip removed nodes; convert runtimeParam.r(N) declarators to imports.
- *   3. Replace remaining inline runtimeParam.r(N) calls with hoisted identifiers.
- *   4. Assemble: prepend import declarations, keep filtered body, append export declarations.
+ * Passes:
+ *   1.  Collect exports:
+ *         - ODP(exportsParam, "name", {get:fn}) — direct named export
+ *         - for-in loop over an object of getters → named exports
+ *         - IIFE batch: !(fn)(exportsParam, {name:getter,...}) → named exports
+ *         - runtimeParam.s(["name", 0, fn]) → default/named export (1-param turbopack)
+ *         - requireParam.d(exportsParam, {...}) → named exports (webpack-style only)
+ *       Also drops: __esModule markers, require.r(exports), "use strict", interop boilerplate.
+ *   2.  Hoist: `var x = runtimeParam.r(N)` / `var x = runtimeParam.i(N)` → `import * as x`.
+ *       Side-effect runtimeParam.r(N) in sequence expressions → `import "./N.js"`.
+ *   3.  Replace remaining inline runtimeParam.r(N) / runtimeParam.i(N) calls with identifiers.
+ *   E.  Collapse Babel slicedToArray expansions.
+ *   F.  Recover JSX from jsx()/jsxs() calls (runs on both body and export statements).
+ *   G.  Remove Babel helpers.
+ *   H.  Prune unused named imports.
+ *   4.  Assemble: prepend imports, keep filtered body, append export declarations.
  */
 export const transformModule = (mod) => {
-    const { fnPath, runtimeParam, moduleParam, exportsParam } = mod;
+    const { fnPath, runtimeParam, moduleParam, exportsParam, requireParam } = mod;
     const body = fnPath.node.body;
     if (!t.isBlockStatement(body))
         return [];
-    // ── Pre-scan: find for-in export loops and their map variable declarations ──
-    // Map from variable name → the VariableDeclaration node that declares it as an export map.
-    // We also track the specific declarator so we can remove just that one if needed.
+    // webpack-style: no turbopack runtime, direct requireParam(N) calls
+    const isWebpackStyle = !runtimeParam && !!requireParam;
+    // ── Pre-scan: find for-in export loops ────────────────────────────────
     const exportMapVarNames = new Set();
-    const exportMapDeclNodes = new Map(); // varName → decl node
+    const exportMapDeclNodes = new Map();
     for (const stmt of body.body) {
         const mapVarName = tryExtractForInExportLoop(stmt, exportsParam);
-        if (mapVarName !== null) {
+        if (mapVarName !== null)
             exportMapVarNames.add(mapVarName);
-        }
     }
     for (const stmt of body.body) {
         if (!t.isVariableDeclaration(stmt))
@@ -39,61 +682,184 @@ export const transformModule = (mod) => {
             }
         }
     }
-    // ── Pass 1: collect exports, mark statement nodes for removal ────────────────
-    const exportMap = new Map(); // exportName → returnExpr
+    // ── Pass 1: collect exports + mark for removal ────────────────────────
+    const exportMap = new Map();
     const stmtsToRemove = new WeakSet();
+    // Collect side-effect requires from sequence expressions (e.g. (ODP, r(N1), r(N2)))
+    const sideEffectRequireIds = new Set();
+    // Webpack CJS re-exports: e.exports = r(N) → export * from './N.js'
+    const reExportIds = new Set();
     for (const stmt of body.body) {
-        // Interop boilerplate.
-        if (isInteropBoilerplate(stmt, moduleParam)) {
+        // Drop "use strict" directives (they become expressions in lax parse mode)
+        if (t.isExpressionStatement(stmt) &&
+            t.isStringLiteral(stmt.expression) &&
+            stmt.expression.value === "use strict") {
             stmtsToRemove.add(stmt);
             continue;
         }
+        // moduleParam.exports = X handling
+        if (moduleParam) {
+            // Step 1: handle simple top-level e.exports = VALUE assignments
+            const cjsRhs = tryExtractModuleExportsRhs(stmt, moduleParam);
+            if (cjsRhs !== null) {
+                stmtsToRemove.add(stmt);
+                // Pure interop: e.exports = exportsParam.default → strip silently
+                if (exportsParam &&
+                    t.isMemberExpression(cjsRhs) &&
+                    !cjsRhs.computed &&
+                    t.isIdentifier(cjsRhs.object, { name: exportsParam }) &&
+                    t.isIdentifier(cjsRhs.property, { name: "default" })) {
+                    continue;
+                }
+                // Not turbopack (no runtimeParam): this is an actual CJS export
+                if (!runtimeParam) {
+                    // e.exports = requireParam(N) → re-export all from N
+                    if (requireParam) {
+                        const reExportId = tryExtractWebpackRequire(cjsRhs, requireParam);
+                        if (reExportId !== null) {
+                            reExportIds.add(reExportId);
+                            continue;
+                        }
+                    }
+                    // e.exports = VALUE → export default VALUE
+                    exportMap.set("default", cjsRhs);
+                }
+                continue;
+            }
+            // Step 2: strip complex nested interop patterns (e.g. conditional with module.exports=exports.default inside).
+            // Only applies when exportsParam is known (2-/3-param modules) — 1-param modules have no
+            // exports param so any e.exports=X might be a real CJS export, not interop.
+            // Also skip SequenceExpression statements — their sub-expressions are handled element-by-element below.
+            if (exportsParam &&
+                (!t.isExpressionStatement(stmt) || !t.isSequenceExpression(stmt.expression))) {
+                if (isInteropBoilerplate(stmt, moduleParam, exportsParam)) {
+                    stmtsToRemove.add(stmt);
+                    continue;
+                }
+            }
+        }
         if (t.isExpressionStatement(stmt)) {
             const expr = stmt.expression;
-            // `Object.defineProperty(r, "__esModule", …)` — just an interop marker.
+            // `Object.defineProperty(exportsParam, "__esModule", …)` — interop marker
             if (isEsModuleMarker(expr, exportsParam)) {
                 stmtsToRemove.add(stmt);
                 continue;
             }
-            // Direct `Object.defineProperty(r, "name", { get: fn })`.
+            // Direct `Object.defineProperty(exportsParam, "name", { get: fn })`
             const direct = tryExtractDefinePropertyExport(expr, exportsParam);
             if (direct) {
                 exportMap.set(direct.exportName, direct.returnExpr);
                 stmtsToRemove.add(stmt);
                 continue;
             }
-            // SequenceExpression: may mix esModule markers and export definitions.
+            // Turbopack IIFE batch export: !(fn)(exportsParam, {name:getter,...})
+            const batchExports = tryExtractBatchIIFEExports(expr, exportsParam);
+            if (batchExports) {
+                for (const [name, retExpr] of batchExports)
+                    exportMap.set(name, retExpr);
+                stmtsToRemove.add(stmt);
+                continue;
+            }
+            // Turbopack 1-param: runtimeParam.s(["name", 0, fn]) → export
+            if (runtimeParam) {
+                const sExport = tryExtractRuntimeSExport(expr, runtimeParam);
+                if (sExport) {
+                    exportMap.set(sExport.exportName, sExport.exportFn);
+                    stmtsToRemove.add(stmt);
+                    continue;
+                }
+            }
+            // webpack requireParam.r(exportsParam) → drop (Pass 1.5)
+            if (requireParam && isRequireDotR(expr, requireParam, exportsParam)) {
+                stmtsToRemove.add(stmt);
+                continue;
+            }
+            // webpack requireParam.d(exportsParam, {...}) → named exports (Pass 1.5)
+            if (requireParam) {
+                const dotDExports = tryExtractRequireDotD(expr, requireParam, exportsParam);
+                if (dotDExports) {
+                    for (const [name, retExpr] of dotDExports)
+                        exportMap.set(name, retExpr);
+                    stmtsToRemove.add(stmt);
+                    continue;
+                }
+            }
+            // Webpack standalone side-effect require: r(N); as a lone expression statement
+            if (isWebpackStyle && requireParam) {
+                const sideEffectId = tryExtractWebpackRequire(expr, requireParam);
+                if (sideEffectId !== null) {
+                    sideEffectRequireIds.add(sideEffectId);
+                    stmtsToRemove.add(stmt);
+                    continue;
+                }
+            }
+            // SequenceExpression: handle (ODP, !(fn)(...), r(N1), r(N2), ...) mixed sequences
             if (t.isSequenceExpression(expr)) {
                 const kept = [];
                 for (const sub of expr.expressions) {
                     if (isEsModuleMarker(sub, exportsParam))
                         continue;
-                    const match = tryExtractDefinePropertyExport(sub, exportsParam);
-                    if (match) {
-                        exportMap.set(match.exportName, match.returnExpr);
+                    const directSub = tryExtractDefinePropertyExport(sub, exportsParam);
+                    if (directSub) {
+                        exportMap.set(directSub.exportName, directSub.returnExpr);
+                        continue;
                     }
-                    else {
-                        kept.push(sub);
+                    const batchSub = tryExtractBatchIIFEExports(sub, exportsParam);
+                    if (batchSub) {
+                        for (const [name, retExpr] of batchSub)
+                            exportMap.set(name, retExpr);
+                        continue;
+                    }
+                    if (requireParam && isRequireDotR(sub, requireParam, exportsParam))
+                        continue;
+                    if (requireParam) {
+                        const dotDSub = tryExtractRequireDotD(sub, requireParam, exportsParam);
+                        if (dotDSub) {
+                            for (const [name, retExpr] of dotDSub)
+                                exportMap.set(name, retExpr);
+                            continue;
+                        }
                     }
+                    // Side-effect require: runtime.r(N) / runtime.i(N) standalone in a sequence
+                    if (runtimeParam) {
+                        const sideEffectId = tryExtractTurbopackRequire(sub, runtimeParam);
+                        if (sideEffectId !== null) {
+                            sideEffectRequireIds.add(sideEffectId);
+                            continue;
+                        }
+                    }
+                    // Webpack side-effect require: requireParam(N) standalone in a sequence
+                    if (isWebpackStyle && requireParam) {
+                        const sideEffectId = tryExtractWebpackRequire(sub, requireParam);
+                        if (sideEffectId !== null) {
+                            sideEffectRequireIds.add(sideEffectId);
+                            continue;
+                        }
+                    }
+                    // Strip complex interop boilerplate sub-expressions in a sequence
+                    // (e.g. `("function"==typeof t.default||...)&&e.exports=t.default`)
+                    if (moduleParam &&
+                        exportsParam &&
+                        isInteropBoilerplate(t.expressionStatement(sub), moduleParam, exportsParam))
+                        continue;
+                    kept.push(sub);
                 }
                 if (kept.length === 0) {
                     stmtsToRemove.add(stmt);
                 }
                 else if (kept.length < expr.expressions.length) {
-                    // Trim the sequence in-place.
                     stmt.expression =
                         kept.length === 1 ? kept[0] : t.sequenceExpression(kept);
                 }
                 continue;
             }
         }
-        // ForInStatement: `for (var k in mapVar) Object.defineProperty(exportsParam, k, …)`.
+        // ForInStatement: `for (var k in mapVar) ODP(exportsParam, k, ...)` (rare direct form)
         const mapVarName = tryExtractForInExportLoop(stmt, exportsParam);
         if (mapVarName !== null) {
             stmtsToRemove.add(stmt);
             const declNode = exportMapDeclNodes.get(mapVarName);
             if (declNode) {
-                // Extract exports from the map object.
                 for (const decl of declNode.declarations) {
                     if (t.isIdentifier(decl.id, { name: mapVarName }) && decl.init && t.isObjectExpression(decl.init)) {
                         const extracted = extractExportsFromMap(decl.init);
@@ -102,25 +868,24 @@ export const transformModule = (mod) => {
                         break;
                     }
                 }
-                // Mark the map variable declaration for removal.
                 if (declNode.declarations.length === 1) {
                     stmtsToRemove.add(declNode);
                 }
                 else {
-                    // Multiple declarators: remove only the export-map one.
                     declNode.declarations = declNode.declarations.filter((d) => !t.isIdentifier(d.id, { name: mapVarName }));
                 }
             }
         }
     }
-    // ── Pass 2: combined filter + require hoisting ───────────────────────────────
+    // ── Pass 2: filter + require hoisting ────────────────────────────────
     const hoistedImports = new Map(); // specifier → importName
     const importNameByNumId = new Map(); // numId → importName
     const filteredBody = [];
     for (const stmt of body.body) {
         if (stmtsToRemove.has(stmt))
             continue;
-        if (t.isVariableDeclaration(stmt)) {
+        // Turbopack-style: `var x = runtime.r(N)` or `var x = runtime.i(N)` → static import
+        if (runtimeParam && t.isVariableDeclaration(stmt)) {
             const keptDeclarators = [];
             for (const decl of stmt.declarations) {
                 if (!t.isIdentifier(decl.id) || !decl.init) {
@@ -137,7 +902,32 @@ export const transformModule = (mod) => {
                     hoistedImports.set(spec, decl.id.name);
                     importNameByNumId.set(numId, decl.id.name);
                 }
-                // Declarator removed — becomes a static import.
+                // Declarator removed — becomes a static import
+            }
+            if (keptDeclarators.length > 0) {
+                filteredBody.push(t.variableDeclaration(stmt.kind, keptDeclarators));
+            }
+            continue;
+        }
+        // Webpack-style: `var x = requireParam(N)` → static import
+        if (isWebpackStyle && requireParam && t.isVariableDeclaration(stmt)) {
+            const keptDeclarators = [];
+            for (const decl of stmt.declarations) {
+                if (!t.isIdentifier(decl.id) || !decl.init) {
+                    keptDeclarators.push(decl);
+                    continue;
+                }
+                const numId = tryExtractWebpackRequire(decl.init, requireParam);
+                if (numId === null) {
+                    keptDeclarators.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 — becomes a static import
             }
             if (keptDeclarators.length > 0) {
                 filteredBody.push(t.variableDeclaration(stmt.kind, keptDeclarators));
@@ -146,32 +936,92 @@ export const transformModule = (mod) => {
         }
         filteredBody.push(stmt);
     }
-    // ── Pass 3: replace remaining inline runtimeParam.r(N) calls ────────────────
-    body.body = filteredBody;
-    fnPath.traverse({
-        CallExpression(p) {
-            const numId = tryExtractTurbopackRequire(p.node, runtimeParam);
-            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 4: assemble — prepend imports, filtered body, append exports ────────
+    // ── Pass 3: replace remaining inline require calls ────────────────────
+    if (runtimeParam) {
+        // Turbopack-style: replace runtime.r(N) / runtime.i(N)
+        body.body = filteredBody;
+        fnPath.traverse({
+            CallExpression(p) {
+                const numId = tryExtractTurbopackRequire(p.node, runtimeParam);
+                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();
+            },
+        });
+    }
+    else if (isWebpackStyle && requireParam) {
+        // Webpack-style: replace requireParam(N) direct calls
+        body.body = filteredBody;
+        fnPath.traverse({
+            CallExpression(p) {
+                const numId = tryExtractWebpackRequire(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();
+            },
+        });
+    }
+    else {
+        body.body = filteredBody;
+    }
+    // ── Build import/export statements ────────────────────────────────────
     const importStmts = [];
+    // Side-effect imports (r(N) inside a sequence, no binding)
+    for (const numId of sideEffectRequireIds) {
+        const spec = `./${numId}.js`;
+        if (!hoistedImports.has(spec)) {
+            importStmts.push(t.importDeclaration([], t.stringLiteral(spec)));
+        }
+    }
+    // Namespace imports
     for (const [spec, name] of hoistedImports) {
         importStmts.push(t.importDeclaration([t.importNamespaceSpecifier(t.identifier(name))], t.stringLiteral(spec)));
     }
-    const exportStmts = [];
+    let exportStmts = [];
+    // webpack CJS re-exports: e.exports = r(N) → export * from './N.js'
+    for (const numId of reExportIds) {
+        const spec = `./${numId}.js`;
+        exportStmts.push(t.exportAllDeclaration(t.stringLiteral(spec)));
+    }
     for (const [exportName, returnExpr] of exportMap) {
         exportStmts.push(makeExportStatement(exportName, returnExpr));
     }
-    return [...importStmts, ...body.body, ...exportStmts];
+    // ── Passes E/F/G/H — cleanup ──────────────────────────────────────────
+    let bodyStmts = [...body.body];
+    bodyStmts = collapseSlicedToArrayDeep(bodyStmts);
+    recoverJSX(bodyStmts);
+    bodyStmts = removeBabelHelpers(bodyStmts);
+    // Also run JSX recovery on export statements — the exported function bodies
+    // (e.g. `export default function() {...}` from e.s([]) pattern) contain JSX.
+    recoverJSX(exportStmts);
+    exportStmts = collapseSlicedToArrayDeep(exportStmts);
+    const finalImports = pruneUnusedNamedImports(importStmts, [...bodyStmts, ...exportStmts]);
+    return [...finalImports, ...bodyStmts, ...exportStmts];
+};
+// ---------------------------------------------------------------------------
+// Webpack-style module transform (for NNN:(e,t,r)=>{...} chunks in Next.js)
+// ---------------------------------------------------------------------------
+/**
+ * Transforms a webpack-style module (NNN:(module,exports,require)=>{...}) into
+ * ECMAScript module statements. Uses the same passes as the turbopack transform
+ * since the param order and patterns are identical — only the export registration
+ * form differs (require.d vs Object.defineProperty, already handled in Pass 1).
+ */
+export const transformWebpackModule = (mod) => {
+    return transformModule(mod);
 };
 //# sourceMappingURL=transform.js.map