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

package/build/refactor/react/index.js

@@ -1,3 +1,5 @@
+// ECMAScript export reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export
+// ECMAScript import reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,630 +9,333 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var _a, _b;
 import chalk from "chalk";
 import parser from "@babel/parser";
 import _traverse from "@babel/traverse";
 import _generator from "@babel/generator";
 import * as t from "@babel/types";
-const traverse = _traverse.default;
-const generate = _generator.default;
+import { cs_mast_init } from "@shriyanss/cs-mast";
+import { isInModuleMap } from "./helpers.js";
+import { validateAndFix } from "./validator.js";
+import { transformModule, transformIndexStatements, applyModuleCleanupPasses, applyLibraryImportRewriting, renameRouteComponents, } from "./transform.js";
+import { classifyLibraryModule, resolveReexportChains } from "./library-classify.js";
+const traverse = ((_a = _traverse.default) !== null && _a !== void 0 ? _a : _traverse);
+const generate = (_b = _generator.default) !== null && _b !== void 0 ? _b : _generator;
+// scat config used when computing experiment-baseline signatures (matches
+// refactor_observations/feature-signatures/<feature>/lit-decl-loop-cond/collisions.json).
+const LIB_SIG_SCAT = ["lit", "decl", "loop", "cond"];
+// Returns the body statements of a top-level IIFE (e.g. `(() => { … })()`), or null.
+const findIifeBody = (program) => {
+    for (const stmt of program.body) {
+        if (!t.isExpressionStatement(stmt))
+            continue;
+        const expr = stmt.expression;
+        if (!t.isCallExpression(expr) || expr.arguments.length !== 0)
+            continue;
+        const callee = expr.callee;
+        if ((t.isArrowFunctionExpression(callee) || t.isFunctionExpression(callee)) &&
+            t.isBlockStatement(callee.body)) {
+            return callee.body.body;
+        }
+    }
+    return null;
+};
+// Returns true when stmt is the webpack lazy-chunk push call:
+// (self.webpackChunk...||[]).push([[chunkId,...], {moduleId: fn, ...}])
+const isLazyChunkPushStmt = (stmt) => {
+    if (!t.isExpressionStatement(stmt))
+        return false;
+    const expr = stmt.expression;
+    if (!t.isCallExpression(expr))
+        return false;
+    const callee = expr.callee;
+    return t.isMemberExpression(callee) && t.isIdentifier(callee.property, { name: "push" });
+};
+// Returns true when a VariableDeclarator's init is the webpack numeric module map
+// object (every property has a NumericLiteral key and a function value).
+const isModuleMapDeclarator = (d) => {
+    if (!t.isObjectExpression(d.init))
+        return false;
+    const props = d.init.properties;
+    if (props.length === 0)
+        return false;
+    return props.every((p) => {
+        if (t.isObjectProperty(p))
+            return (t.isNumericLiteral(p.key) && (t.isFunctionExpression(p.value) || t.isArrowFunctionExpression(p.value)));
+        if (t.isObjectMethod(p))
+            return t.isNumericLiteral(p.key);
+        return false;
+    });
+};
 /**
- * Refactors a webpack-bundled React chunk into a more readable form.
+ * Rewrites a webpack-bundled React chunk by splitting the numeric module map
+ * into individual ECMAScript module files.
  *
- * Recognises the standard webpack 5 / React 18 production bundle shape:
- *   - An outer IIFE that holds a `{ <id>: function(module, exports, require) { ... } }`
- *     module map.
- *   - Each inner module function uses positional params named `(module, exports, require)`
- *     (minifier locals — names vary per chunk).
- *   - React's public surface lives in modules identifiable by content fingerprint
- *     (the public hooks delegate to `R.current.<hook>(...)`).
- *
- * Two layers of rewrites happen:
- *
- *   1. Webpack-level:
- *      - `<require>(<n>)`                              → `require("./<n>.js")`
- *      - `<require>.d(<exports>, { k: () => local })`  → captured into export map
- *      - `Object.defineProperty(<exports>, "k", { ... })` → captured into export map
- *
- *   2. React-level:
- *      - Catalog every inner module by content fingerprint to learn which are
- *        `react`, `react/jsx-runtime`, `react-dom/client`.
- *      - In each module body, find `var <local> = <require>(<n>)` to learn which
- *        local aliases which React module within that scope.
- *      - Rewrite `(0, <reactLocal>.<hook>)(args)` → `<hook>(args)` and collect
- *        `<hook>` into the file-level react import set. Similarly for jsx-runtime
- *        and react-dom/client.
- *      - Any remaining `(0, X.Y)(args)` flattens to `X.Y(args)` (always safe).
- *
- * Lossy — for human inspection only.
+ *   Step 1 – Find the `var X = { <numId>: function(e,n,t){…}, … }` module map.
+ *   Step 2 – For each module:
+ *              a) Convert `<moduleParam>.exports = <requireParam>(N)` → `export * from "./N.js"`
+ *                 (and `<moduleParam>.exports = <expr>` → `export default <expr>`),
+ *                 including inside top-level sequence expressions.
+ *              b) Convert `<exportsParam>.<propName> = <rhs>` → ECMAScript named exports
+ *                 (per MDN export reference) for any module that has an exports param.
+ *              c) Hoist `var <name> = <requireParam>(N)` to `import * as <name> from "./N.js"`.
+ *              d) Replace remaining inline `<requireParam>(N)` calls with a synthesized
+ *                 namespace import reference.
+ *              e) Strip the outer function wrapper.
+ *   Step 3 – Validate generated code with Babel; iteratively drop/downgrade statements
+ *              that still cause parse errors.
+ *   Step 4 – Collect all IIFE body statements that are NOT part of the module map and
+ *              write them to `index.js` (entrypoint bootstrap, app component functions,
+ *              the ReactDOM.render call, etc.).
  */
-const REACT_HOOK_NAMES = new Set([
-    "useState",
-    "useEffect",
-    "useRef",
-    "useContext",
-    "useReducer",
-    "useMemo",
-    "useCallback",
-    "useId",
-    "useTransition",
-    "useLayoutEffect",
-    "useDeferredValue",
-    "useImperativeHandle",
-    "useDebugValue",
-    "useSyncExternalStore",
-    "useInsertionEffect",
-    "useOptimistic",
-    "useActionState",
-    "useFormStatus",
-]);
-const REACT_TOP_LEVEL_API_NAMES = new Set([
-    "createContext",
-    "createElement",
-    "createRef",
-    "forwardRef",
-    "memo",
-    "lazy",
-    "startTransition",
-    "Fragment",
-    "Children",
-    "cloneElement",
-    "isValidElement",
-    "use",
-    "act",
-]);
-const JSX_RUNTIME_NAMES = new Set(["jsx", "jsxs", "jsxDEV", "Fragment"]);
-const REACT_DOM_CLIENT_NAMES = new Set(["createRoot", "hydrateRoot"]);
-const refactorReact = (chunk) => __awaiter(void 0, void 0, void 0, function* () {
-    console.log(chalk.cyan(`[i] Refactoring React chunk: ${chunk.id}`));
+const isLibrarySig = (sig, libSigs) => !!(sig && libSigs && libSigs.has(sig));
+// Minimum fraction of a module's sub-tree signatures that must match the library
+// baseline before the module is classified as library code. A value of 1.0 means
+// every signature must match (too strict — misses partial-lib modules). A value
+// of 0.0 means any single match suffices (too loose — false-positives on app modules
+// that happen to share a helper with library code). 0.5 is a reasonable default:
+// pure library modules score close to 1.0 while app modules with inline CSS helpers
+// or a stray shared utility typically score well below 0.5.
+const LIB_CLASSIFICATION_THRESHOLD = 0.51;
+// Hash a single module's function body using cs_mast_init and look the signature
+// up against the count=18 baseline set. Returns true when the fraction of the
+// module's sub-tree signatures that match the baseline exceeds LIB_CLASSIFICATION_THRESHOLD.
+const moduleIsLibrary = (mod, libSigs, scatOverride) => {
+    if (!libSigs || libSigs.size === 0)
+        return false;
+    const fnNode = mod.fnPath.node;
+    if (!t.isBlockStatement(fnNode.body))
+        return false;
+    const body = fnNode.body;
+    try {
+        const code = generate(body).code;
+        const tree = cs_mast_init(code, {
+            hash: "sha256",
+            scat: scatOverride !== null && scatOverride !== void 0 ? scatOverride : LIB_SIG_SCAT,
+            sinc: [],
+            lang: "js",
+            prsr: "@babel/parser",
+        });
+        const sigs = [...tree._signatureMap.keys()];
+        if (sigs.length === 0)
+            return false;
+        const matchCount = sigs.filter((sig) => isLibrarySig(sig, libSigs)).length;
+        const fraction = matchCount / sigs.length;
+        return fraction >= LIB_CLASSIFICATION_THRESHOLD;
+    }
+    catch (_a) {
+        // unparseable / unhashable — fall through and treat as non-library
+    }
+    return false;
+};
+// Returns true when a 1-param module looks like a style-loader runtime helper.
+// Matches the addStyles module (contains domAPI + update) and the
+// styleTagTransform module (sets cssText or calls createTextNode).
+const isStyleLoaderModule = (mod) => {
+    if (mod.paramCount !== 1)
+        return false;
+    const fnNode = mod.fnPath.node;
+    if (!t.isBlockStatement(fnNode.body))
+        return false;
+    const body = fnNode.body;
+    try {
+        const code = generate(body).code;
+        if (code.includes("domAPI") && code.includes("update"))
+            return true;
+        if (code.includes("styleSheet") && code.includes("cssText"))
+            return true;
+        if (code.includes("styleTagTransform") || code.includes("insertStyleElement"))
+            return true;
+    }
+    catch (_a) {
+        // unparseable
+    }
+    return false;
+};
+// Returns true when a 3-param module is a CSS content module (pushes a CSS array
+// with an id + CSS string via requireParam.d).
+const isCssModuleEntry = (mod) => {
+    if (mod.paramCount !== 3)
+        return false;
+    const fnNode = mod.fnPath.node;
+    if (!t.isBlockStatement(fnNode.body))
+        return false;
+    const body = fnNode.body;
+    try {
+        const code = generate(body).code;
+        // CSS content modules push an array of [moduleId, cssString, ""] and register via .d
+        if (code.includes(".push(") && code.includes(".id,") && code.includes(".d("))
+            return true;
+    }
+    catch (_a) {
+        // unparseable
+    }
+    return false;
+};
+const refactorReact = (chunk, libSigs, externalLibModuleMap, classifyAllAsLibrary, scatOverride) => __awaiter(void 0, void 0, void 0, function* () {
+    console.log(chalk.cyan(`[i] Processing React bundle: ${chunk.id}`));
     const ast = parser.parse(chunk.code, {
         sourceType: "unambiguous",
         plugins: ["jsx", "typescript"],
         errorRecovery: true,
     });
     const modules = [];
-    const captureModule = (id, fnPath, params) => {
-        if (params.length < 2)
+    const captureProperty = (path) => {
+        if (!isInModuleMap(path))
+            return;
+        const key = path.node.key;
+        if (!t.isNumericLiteral(key)) {
+            if (t.isStringLiteral(key) && /[a-zA-Z]/.test(key.value)) {
+                console.log(chalk.yellow(`[!] Alphanumeric module ID "${key.value}" detected — not yet supported, skipping (please open a PR)`));
+            }
             return;
-        const m = params[0], e = params[1], r = params.length >= 3 ? params[2] : undefined;
-        if (!t.isIdentifier(m) || !t.isIdentifier(e))
+        }
+        const value = path.node.value;
+        if (!t.isFunctionExpression(value) && !t.isArrowFunctionExpression(value))
             return;
-        if (r !== undefined && !t.isIdentifier(r))
+        const id = String(key.value);
+        const params = value.params;
+        if (params.length > 3) {
+            console.log(chalk.yellow(`[!] Module ${id} has ${params.length} params — not yet researched, skipping`));
             return;
+        }
+        const moduleParam = params[0] && t.isIdentifier(params[0]) ? params[0].name : "";
+        const exportsParam = params[1] && t.isIdentifier(params[1]) ? params[1].name : "";
+        const requireParam = params.length >= 3 && t.isIdentifier(params[2]) ? params[2].name : undefined;
         modules.push({
             id,
-            fnPath,
-            moduleParam: m.name,
-            exportsParam: e.name,
-            requireParam: r ? r.name : undefined,
+            fnPath: path.get("value"),
+            paramCount: params.length,
+            moduleParam,
+            exportsParam,
+            requireParam,
         });
     };
-    // Only capture entries whose key is numeric AND whose grandparent is an
-    // ObjectExpression at module level (the webpack module map). This filters
-    // out the many `useImperativeHandle(e, n, t) { ... }` ObjectMethods inside
-    // React's own source, which happen to share the 3-param shape.
-    const isInModuleMap = (path) => {
-        const objectParent = path.parentPath;
-        if (!objectParent || !objectParent.isObjectExpression())
-            return false;
-        // The ObjectExpression's parent should be the module-map assignment:
-        //   var e = { 540: fn, 338: fn, ... }
-        // i.e. a VariableDeclarator whose init is the object.
-        const objHolder = objectParent.parentPath;
-        if (!objHolder)
-            return false;
-        if (objHolder.isVariableDeclarator())
-            return true;
-        // Some bundles place the map directly inside the IIFE arrow body's
-        // return / argument position — accept those too.
-        if (objHolder.isAssignmentExpression())
-            return true;
-        return false;
-    };
-    traverse(ast, {
-        ObjectProperty(path) {
-            if (!t.isNumericLiteral(path.node.key))
-                return;
-            if (!isInModuleMap(path))
-                return;
-            const value = path.node.value;
-            if (!t.isFunctionExpression(value) && !t.isArrowFunctionExpression(value))
-                return;
-            const id = String(path.node.key.value);
-            const valuePath = path.get("value");
-            captureModule(id, valuePath, value.params);
-        },
-        ObjectMethod(path) {
-            if (!t.isNumericLiteral(path.node.key))
-                return;
-            if (!isInModuleMap(path))
-                return;
-            const id = String(path.node.key.value);
-            captureModule(id, path, path.node.params);
-        },
-    });
-    const catalog = new Map();
-    const exportCollections = new Map();
-    // Track which modules are pure re-exporters: body of form
-    //   e.exports = t(N)
-    // → reExportTargetOf[mod.id] = "N"
-    const reExportTargetOf = new Map();
-    for (const mod of modules) {
-        const exportsMap = new Map();
-        const exportsParamAssignKeys = new Set();
-        let dispatchCallCount = 0;
-        let reExportTarget = null;
-        // Quick re-export detection: a module whose ONLY non-trivial statement
-        // is `<module>.exports = <require>(<n>)`.
-        const body = mod.fnPath.node.body;
-        if (t.isBlockStatement(body)) {
-            for (const stmt of body.body) {
-                if (!t.isExpressionStatement(stmt))
-                    continue;
-                const expr = stmt.expression;
-                if (t.isAssignmentExpression(expr) &&
-                    t.isMemberExpression(expr.left) &&
-                    t.isIdentifier(expr.left.object, { name: mod.moduleParam }) &&
-                    t.isIdentifier(expr.left.property, { name: "exports" }) &&
-                    t.isCallExpression(expr.right) &&
-                    t.isIdentifier(expr.right.callee) &&
-                    mod.requireParam &&
-                    expr.right.callee.name === mod.requireParam &&
-                    expr.right.arguments.length === 1 &&
-                    t.isNumericLiteral(expr.right.arguments[0])) {
-                    reExportTarget = String(expr.right.arguments[0].value);
-                    break;
-                }
+    const captureMethod = (path) => {
+        if (!isInModuleMap(path))
+            return;
+        const key = path.node.key;
+        if (!t.isNumericLiteral(key)) {
+            if (t.isStringLiteral(key) && /[a-zA-Z]/.test(key.value)) {
+                console.log(chalk.yellow(`[!] Alphanumeric module ID "${key.value}" detected — not yet supported, skipping (please open a PR)`));
             }
+            return;
         }
-        if (reExportTarget) {
-            reExportTargetOf.set(mod.id, reExportTarget);
-        }
-        mod.fnPath.traverse({
-            CallExpression(p) {
-                const node = p.node;
-                // <require>.d(<exports>, { ... })
-                if (mod.requireParam &&
-                    t.isMemberExpression(node.callee) &&
-                    t.isIdentifier(node.callee.object, { name: mod.requireParam }) &&
-                    t.isIdentifier(node.callee.property, { name: "d" }) &&
-                    node.arguments.length === 2 &&
-                    t.isIdentifier(node.arguments[0], { name: mod.exportsParam }) &&
-                    t.isObjectExpression(node.arguments[1])) {
-                    for (const prop of node.arguments[1].properties) {
-                        if (!t.isObjectProperty(prop))
-                            continue;
-                        const k = getStaticKey(prop.key);
-                        if (!k)
-                            continue;
-                        const local = extractGetterLocal(prop.value);
-                        if (!local)
-                            continue;
-                        exportsMap.set(k, local);
-                    }
-                    return;
-                }
-                // Object.defineProperty(<exports>, "k", { get: ... })
-                if (t.isMemberExpression(node.callee) &&
-                    t.isIdentifier(node.callee.object, { name: "Object" }) &&
-                    t.isIdentifier(node.callee.property, { name: "defineProperty" }) &&
-                    node.arguments.length === 3 &&
-                    t.isIdentifier(node.arguments[0], { name: mod.exportsParam }) &&
-                    t.isStringLiteral(node.arguments[1]) &&
-                    t.isObjectExpression(node.arguments[2])) {
-                    const k = node.arguments[1].value;
-                    for (const prop of node.arguments[2].properties) {
-                        if (!t.isObjectProperty(prop))
-                            continue;
-                        if (getStaticKey(prop.key) !== "get")
-                            continue;
-                        const local = extractGetterLocal(prop.value);
-                        if (!local)
-                            continue;
-                        exportsMap.set(k, local);
-                    }
-                    return;
-                }
-                // Call shape: <X>.current.<hookName>(args) — react dispatch
-                if (t.isMemberExpression(node.callee) &&
-                    t.isMemberExpression(node.callee.object) &&
-                    t.isIdentifier(node.callee.object.property, {
-                        name: "current",
-                    }) &&
-                    t.isIdentifier(node.callee.property) &&
-                    REACT_HOOK_NAMES.has(node.callee.property.name)) {
-                    dispatchCallCount++;
-                }
-            },
-            AssignmentExpression(p) {
-                // <exportsParam>.K = ...  (module-scope assignment to exports)
-                const left = p.node.left;
-                if (t.isMemberExpression(left) &&
-                    t.isIdentifier(left.object, { name: mod.exportsParam }) &&
-                    t.isIdentifier(left.property)) {
-                    const minLocal = left.property.name;
-                    exportsParamAssignKeys.add(minLocal);
-                    // If the RHS is `<ident>.<canonicalName>`, learn that the
-                    // exports name `minLocal` corresponds to that canonical
-                    // name. e.g. `n.H = r.createRoot` ⇒ exportsMap["createRoot"] = "H".
-                    const right = p.node.right;
-                    if (t.isMemberExpression(right) && t.isIdentifier(right.property)) {
-                        const canonical = right.property.name;
-                        if (!exportsMap.has(canonical)) {
-                            exportsMap.set(canonical, minLocal);
-                        }
-                    }
-                }
-            },
-        });
-        let kind = null;
-        if (dispatchCallCount > 0) {
-            kind = "react";
-        }
-        else if ((exportsParamAssignKeys.has("jsx") && exportsParamAssignKeys.has("jsxs")) ||
-            (exportsMap.has("jsx") && exportsMap.has("jsxs"))) {
-            kind = "react/jsx-runtime";
-        }
-        else if (exportsParamAssignKeys.has("createRoot") || exportsMap.has("createRoot")) {
-            kind = "react-dom/client";
-        }
-        if (kind) {
-            catalog.set(mod.id, { kind, exportMap: exportsMap });
-        }
-        if (exportsMap.size > 0) {
-            const arr = [];
-            for (const [k, v] of exportsMap)
-                arr.push({ key: k, local: v });
-            exportCollections.set(mod.id, arr);
-        }
-    }
-    // Resolve re-export chains: if module M is `e.exports = t(N)` and N is
-    // classified, M inherits N's kind. Iterate until no new classifications.
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const [source, target] of reExportTargetOf) {
-            if (catalog.has(source))
-                continue;
-            const tgt = catalog.get(target);
-            if (tgt) {
-                catalog.set(source, { kind: tgt.kind, exportMap: tgt.exportMap });
-                changed = true;
-            }
+        const id = String(key.value);
+        const params = path.node.params;
+        if (params.length > 3) {
+            console.log(chalk.yellow(`[!] Module ${id} has ${params.length} params — not yet researched, skipping`));
+            return;
         }
-    }
-    const reactImports = new Set();
-    const jsxRuntimeImports = new Set();
-    const reactDomImports = new Set();
-    for (const mod of modules) {
-        if (!mod.requireParam)
-            continue; // 2-param modules can't have require()
-        const localAliases = new Map();
-        mod.fnPath.traverse({
-            VariableDeclarator(p) {
-                const id = p.node.id;
-                const init = p.node.init;
-                if (t.isIdentifier(id) &&
-                    init &&
-                    t.isCallExpression(init) &&
-                    t.isIdentifier(init.callee, { name: mod.requireParam }) &&
-                    init.arguments.length === 1 &&
-                    t.isNumericLiteral(init.arguments[0])) {
-                    const requireId = String(init.arguments[0].value);
-                    const entry = catalog.get(requireId);
-                    if (entry) {
-                        localAliases.set(id.name, { kind: entry.kind, entry });
-                    }
-                }
-            },
-        });
-        mod.fnPath.traverse({
-            CallExpression: {
-                exit(p) {
-                    const node = p.node;
-                    if (t.isIdentifier(node.callee, { name: mod.requireParam }) &&
-                        node.arguments.length === 1 &&
-                        t.isNumericLiteral(node.arguments[0])) {
-                        const numId = node.arguments[0].value;
-                        p.replaceWith(t.callExpression(t.identifier("require"), [t.stringLiteral(`./${numId}.js`)]));
-                        return;
-                    }
-                    if (t.isMemberExpression(node.callee) &&
-                        t.isIdentifier(node.callee.object, { name: mod.requireParam }) &&
-                        t.isIdentifier(node.callee.property, { name: "d" }) &&
-                        node.arguments.length === 2 &&
-                        t.isIdentifier(node.arguments[0], { name: mod.exportsParam })) {
-                        p.replaceWith(t.identifier("void 0"));
-                        return;
-                    }
-                    if (t.isMemberExpression(node.callee) &&
-                        t.isIdentifier(node.callee.object, { name: "Object" }) &&
-                        t.isIdentifier(node.callee.property, { name: "defineProperty" }) &&
-                        node.arguments.length === 3 &&
-                        t.isIdentifier(node.arguments[0], { name: mod.exportsParam })) {
-                        p.replaceWith(t.identifier("void 0"));
-                        return;
-                    }
-                    if (t.isSequenceExpression(node.callee) &&
-                        node.callee.expressions.length === 2 &&
-                        t.isNumericLiteral(node.callee.expressions[0], { value: 0 }) &&
-                        (t.isMemberExpression(node.callee.expressions[1]) || t.isIdentifier(node.callee.expressions[1]))) {
-                        const inner = node.callee.expressions[1];
-                        // If the MemberExpression visitor already rewrote the
-                        // member to a bare Identifier, just strip the `(0, …)`
-                        // wrapper. Otherwise pass through the recognition pass.
-                        const callee = t.isMemberExpression(inner)
-                            ? rewriteRecognisedMember(inner, localAliases, reactImports, jsxRuntimeImports, reactDomImports)
-                            : inner;
-                        p.replaceWith(t.callExpression(callee, node.arguments));
-                        return;
-                    }
-                    if (t.isMemberExpression(node.callee)) {
-                        const member = node.callee;
-                        if (t.isIdentifier(member.object) && localAliases.has(member.object.name)) {
-                            const newCallee = rewriteRecognisedMember(member, localAliases, reactImports, jsxRuntimeImports, reactDomImports);
-                            // Only replace when the callee changed; otherwise
-                            // we'd rebuild the same node and traverse would loop.
-                            if (newCallee !== member) {
-                                p.replaceWith(t.callExpression(newCallee, node.arguments));
-                            }
-                            return;
-                        }
-                    }
-                },
-            },
-            MemberExpression: {
-                exit(p) {
-                    if (p.parent && t.isCallExpression(p.parent) && p.parent.callee === p.node)
-                        return;
-                    if (!t.isIdentifier(p.node.object) || !t.isIdentifier(p.node.property))
-                        return;
-                    const aliased = localAliases.get(p.node.object.name);
-                    if (!aliased)
-                        return;
-                    const prop = p.node.property.name;
-                    if (aliased.kind === "react/jsx-runtime" && JSX_RUNTIME_NAMES.has(prop)) {
-                        jsxRuntimeImports.add(prop);
-                        p.replaceWith(t.identifier(prop));
-                        return;
-                    }
-                    if (aliased.kind === "react") {
-                        if (REACT_HOOK_NAMES.has(prop) || REACT_TOP_LEVEL_API_NAMES.has(prop)) {
-                            reactImports.add(prop);
-                            p.replaceWith(t.identifier(prop));
-                            return;
-                        }
-                    }
-                    if (aliased.kind === "react-dom/client") {
-                        for (const [canonical, minLocal] of aliased.entry.exportMap) {
-                            if (minLocal === prop && REACT_DOM_CLIENT_NAMES.has(canonical)) {
-                                reactDomImports.add(canonical);
-                                p.replaceWith(t.identifier(canonical));
-                                return;
-                            }
-                        }
-                    }
-                },
-            },
+        const moduleParam = params[0] && t.isIdentifier(params[0]) ? params[0].name : "";
+        const exportsParam = params[1] && t.isIdentifier(params[1]) ? params[1].name : "";
+        const requireParam = params.length >= 3 && t.isIdentifier(params[2]) ? params[2].name : undefined;
+        modules.push({
+            id,
+            fnPath: path,
+            paramCount: params.length,
+            moduleParam,
+            exportsParam,
+            requireParam,
         });
-    }
-    // ──────────────────────────────────────────────────────────────────
-    // Pass 4 (global): catch IIFE-level `var X = <any>(<numericId>)` aliases
-    // and rewrite the user-entry callsites at the outermost scope, which the
-    // per-module pass cannot reach because the entry-IIFE wrapper has 0 params
-    // (no positional require). The catalog match keeps this safe — only known
-    // React-family module IDs trigger alias substitution.
-    // ──────────────────────────────────────────────────────────────────
-    const globalAliases = new Map();
+    };
     traverse(ast, {
-        VariableDeclarator(p) {
-            const id = p.node.id;
-            const init = p.node.init;
-            if (t.isIdentifier(id) &&
-                init &&
-                t.isCallExpression(init) &&
-                t.isIdentifier(init.callee) &&
-                init.arguments.length === 1 &&
-                t.isNumericLiteral(init.arguments[0])) {
-                const requireId = String(init.arguments[0].value);
-                const entry = catalog.get(requireId);
-                if (entry) {
-                    globalAliases.set(id.name, { kind: entry.kind, entry });
-                }
-            }
-        },
+        ObjectProperty: captureProperty,
+        ObjectMethod: captureMethod,
     });
-    if (globalAliases.size > 0) {
-        traverse(ast, {
-            CallExpression: {
-                exit(p) {
-                    const node = p.node;
-                    if (t.isSequenceExpression(node.callee) &&
-                        node.callee.expressions.length === 2 &&
-                        t.isNumericLiteral(node.callee.expressions[0], { value: 0 }) &&
-                        (t.isMemberExpression(node.callee.expressions[1]) || t.isIdentifier(node.callee.expressions[1]))) {
-                        const inner = node.callee.expressions[1];
-                        const callee = t.isMemberExpression(inner)
-                            ? rewriteRecognisedMember(inner, globalAliases, reactImports, jsxRuntimeImports, reactDomImports)
-                            : inner;
-                        p.replaceWith(t.callExpression(callee, node.arguments));
-                        return;
-                    }
-                    if (t.isMemberExpression(node.callee)) {
-                        const member = node.callee;
-                        if (t.isIdentifier(member.object) && globalAliases.has(member.object.name)) {
-                            const newCallee = rewriteRecognisedMember(member, globalAliases, reactImports, jsxRuntimeImports, reactDomImports);
-                            if (newCallee !== member) {
-                                p.replaceWith(t.callExpression(newCallee, node.arguments));
-                            }
-                            return;
-                        }
-                    }
-                },
-            },
-            MemberExpression: {
-                exit(p) {
-                    if (p.parent && t.isCallExpression(p.parent) && p.parent.callee === p.node)
-                        return;
-                    if (!t.isIdentifier(p.node.object) || !t.isIdentifier(p.node.property))
-                        return;
-                    const aliased = globalAliases.get(p.node.object.name);
-                    if (!aliased)
-                        return;
-                    const prop = p.node.property.name;
-                    if (aliased.kind === "react/jsx-runtime" && JSX_RUNTIME_NAMES.has(prop)) {
-                        jsxRuntimeImports.add(prop);
-                        p.replaceWith(t.identifier(prop));
-                        return;
-                    }
-                    if (aliased.kind === "react" &&
-                        (REACT_HOOK_NAMES.has(prop) || REACT_TOP_LEVEL_API_NAMES.has(prop))) {
-                        reactImports.add(prop);
-                        p.replaceWith(t.identifier(prop));
-                        return;
-                    }
-                    if (aliased.kind === "react-dom/client") {
-                        for (const [canonical, minLocal] of aliased.entry.exportMap) {
-                            if (minLocal === prop && REACT_DOM_CLIENT_NAMES.has(canonical)) {
-                                reactDomImports.add(canonical);
-                                p.replaceWith(t.identifier(canonical));
-                                return;
-                            }
-                        }
-                    }
-                },
-            },
-        });
+    console.log(chalk.cyan(`[i] Found ${modules.length} modules`));
+    // Detect lazy chunk bundles: no IIFE wrapper, program body is entirely push() calls.
+    // Modules in lazy chunks are always application code — skip library classification for them.
+    // Also don't generate index.js from the push statement (it contains no bootstrap logic).
+    const iifeBody = findIifeBody(ast.program);
+    const isLazyBundle = iifeBody === null && ast.program.body.length > 0 && ast.program.body.every(isLazyChunkPushStmt);
+    if (isLazyBundle) {
+        console.log(chalk.cyan(`[i] Detected lazy chunk format — skipping library classification`));
     }
-    let codeCopy = generate(ast).code;
-    const importLines = [];
-    if (reactImports.size > 0) {
-        importLines.push(`import { ${Array.from(reactImports).sort().join(", ")} } from "react";`);
-    }
-    if (jsxRuntimeImports.size > 0) {
-        importLines.push(`import { ${Array.from(jsxRuntimeImports).sort().join(", ")} } from "react/jsx-runtime";`);
-    }
-    if (reactDomImports.size > 0) {
-        importLines.push(`import { ${Array.from(reactDomImports).sort().join(", ")} } from "react-dom/client";`);
-    }
-    const header = importLines.length > 0 ? `${importLines.join("\n")}\n\n` : "";
-    const allExports = [];
-    for (const arr of exportCollections.values())
-        allExports.push(...arr);
-    const codeHasDefaultExport = /\bexport\s+default\b|\bas\s+default\b/.test(codeCopy);
-    let trailingExports = "";
-    if (allExports.length > 0) {
-        const usedKeys = new Set();
-        const usedLocals = new Set();
-        const named = [];
-        let collisionIndex = 0;
-        const defaultLines = [];
-        for (const entry of allExports) {
-            if (usedLocals.has(entry.local))
+    const files = {};
+    // moduleId → LibraryModuleInfo for modules that are library-classified (in this chunk)
+    const libModuleMap = new Map();
+    let libraryCount = 0;
+    // Collect non-library module statements before applying Pass D, so we can use the
+    // fully-resolved libModuleMap (including re-export chains) when rewriting imports.
+    const pendingModules = [];
+    for (const mod of modules) {
+        // classifyAllAsLibrary: used for vendor chunks outside mapped.json where we want
+        // to extract library export maps without generating any output files.
+        const isLib = classifyAllAsLibrary || (!isLazyBundle && moduleIsLibrary(mod, libSigs, scatOverride));
+        // Detect style-loader and CSS content modules regardless of baseline signatures.
+        if (!classifyAllAsLibrary && !isLib && !isLazyBundle) {
+            const styleLoaderType = isStyleLoaderModule(mod)
+                ? "style-loader"
+                : isCssModuleEntry(mod)
+                    ? "css-module"
+                    : null;
+            if (styleLoaderType !== null) {
+                console.log(chalk.gray(`[-] Module ${mod.id} detected as ${styleLoaderType} — skipping`));
+                libModuleMap.set(mod.id, { type: styleLoaderType, exportMap: new Map() });
+                libraryCount++;
                 continue;
-            usedLocals.add(entry.local);
-            let key = entry.key;
-            if (usedKeys.has(key)) {
-                collisionIndex += 1;
-                key = `${entry.key}_${collisionIndex}`;
-            }
-            usedKeys.add(key);
-            if (key === "default") {
-                if (!codeHasDefaultExport)
-                    defaultLines.push(`export default ${entry.local};`);
-            }
-            else {
-                named.push({ key, local: entry.local });
             }
         }
-        const parts = [];
-        if (named.length > 0) {
-            const namedList = named.map(({ key, local }) => (key === local ? key : `${local} as ${key}`)).join(", ");
-            parts.push(`/* webpack-derived exports — keys may collide across modules in the chunk */`);
-            parts.push(`export { ${namedList} };`);
+        if (isLib) {
+            console.log(chalk.gray(`[-] Module ${mod.id} matches library baseline — skipping`));
+            libraryCount++;
+            // Classify the library module so import rewriting can use proper named imports
+            const info = classifyLibraryModule(mod);
+            libModuleMap.set(mod.id, info);
+            continue;
         }
-        parts.push(...defaultLines);
-        if (parts.length > 0)
-            trailingExports = `\n\n${parts.join("\n")}`;
-    }
-    else {
-        let functionName = null;
-        traverse(ast, {
-            FunctionDeclaration(path) {
-                if (path.parent.type === "Program" && path.node.id) {
-                    functionName = path.node.id.name;
-                    path.stop();
-                }
-            },
-            VariableDeclarator(path) {
-                if (path.parentPath.parent.type === "Program" &&
-                    path.node.init &&
-                    path.node.init.type === "ArrowFunctionExpression" &&
-                    path.node.id.type === "Identifier") {
-                    functionName = path.node.id.name;
-                    path.stop();
-                }
-            },
-        });
-        if (functionName && !codeHasDefaultExport)
-            trailingExports = `\n\nexport default ${functionName};`;
-    }
-    return `${header}${codeCopy}${trailingExports}`;
-});
-const rewriteRecognisedMember = (member, localAliases, reactImports, jsxImports, reactDomImports) => {
-    if (!t.isIdentifier(member.object) || !t.isIdentifier(member.property))
-        return member;
-    const aliased = localAliases.get(member.object.name);
-    if (!aliased)
-        return member;
-    const prop = member.property.name;
-    if (aliased.kind === "react" && (REACT_HOOK_NAMES.has(prop) || REACT_TOP_LEVEL_API_NAMES.has(prop))) {
-        reactImports.add(prop);
-        return t.identifier(prop);
-    }
-    if (aliased.kind === "react/jsx-runtime" && JSX_RUNTIME_NAMES.has(prop)) {
-        jsxImports.add(prop);
-        return t.identifier(prop);
+        const statements = applyModuleCleanupPasses(transformModule(mod));
+        pendingModules.push({ id: mod.id, statements });
     }
-    if (aliased.kind === "react-dom/client") {
-        for (const [canonical, minLocal] of aliased.entry.exportMap) {
-            if (minLocal === prop && REACT_DOM_CLIENT_NAMES.has(canonical)) {
-                reactDomImports.add(canonical);
-                return t.identifier(canonical);
-            }
+    // Resolve re-export chains (e.g. 338 → 247/react-dom-client, 540 → 287/React) so shim modules
+    // get the right library type. Always run for vendor pre-scans (classifyAllAsLibrary), and for
+    // normal non-lazy chunks when a library baseline is provided.
+    if (classifyAllAsLibrary || (!isLazyBundle && libSigs && libSigs.size > 0)) {
+        if (!isLazyBundle && libSigs && libSigs.size > 0) {
+            console.log(chalk.cyan(`[i] Library modules skipped: ${libraryCount}/${modules.length}`));
         }
+        resolveReexportChains(libModuleMap, modules);
     }
-    return member;
-};
-const getStaticKey = (node) => {
-    if (t.isIdentifier(node))
-        return node.name;
-    if (t.isStringLiteral(node))
-        return node.value;
-    if (t.isNumericLiteral(node))
-        return String(node.value);
-    return null;
-};
-const extractGetterLocal = (node) => {
-    if (t.isArrowFunctionExpression(node)) {
-        if (t.isIdentifier(node.body))
-            return node.body.name;
-        if (t.isBlockStatement(node.body)) {
-            for (const stmt of node.body.body) {
-                if (t.isReturnStatement(stmt) && stmt.argument && t.isIdentifier(stmt.argument)) {
-                    return stmt.argument.name;
-                }
-            }
+    // Merged map: prefer locally-classified entries over external ones (local classification
+    // is more precise for this specific bundle version).
+    const mergedLibMap = new Map([...(externalLibModuleMap !== null && externalLibModuleMap !== void 0 ? externalLibModuleMap : []), ...libModuleMap]);
+    // Apply Pass D (library-aware import rewriting) using the merged map, then validate.
+    for (const { id, statements } of pendingModules) {
+        const afterD = mergedLibMap.size > 0 ? applyLibraryImportRewriting(statements, mergedLibMap) : statements;
+        const afterRename = renameRouteComponents(afterD);
+        const code = validateAndFix(afterRename, id);
+        if (code === null) {
+            console.log(chalk.yellow(`[~] Module ${id} skipped due to unresolvable syntax errors`));
+            continue;
         }
+        files[id] = code;
     }
-    if (t.isFunctionExpression(node) && t.isBlockStatement(node.body)) {
-        for (const stmt of node.body.body) {
-            if (t.isReturnStatement(stmt) && stmt.argument && t.isIdentifier(stmt.argument)) {
-                return stmt.argument.name;
+    // Collect everything in the IIFE body that is NOT the module-map variable into index.js.
+    // Skip this step for lazy chunks — their push statement contains no bootstrap logic.
+    if (!isLazyBundle) {
+        const topLevel = iifeBody !== null && iifeBody !== void 0 ? iifeBody : ast.program.body;
+        const indexStatements = [];
+        for (const stmt of topLevel) {
+            if (t.isVariableDeclaration(stmt)) {
+                const remaining = stmt.declarations.filter((d) => !isModuleMapDeclarator(d));
+                if (remaining.length > 0)
+                    indexStatements.push(t.variableDeclaration(stmt.kind, remaining));
             }
+            else {
+                indexStatements.push(stmt);
+            }
+        }
+        if (indexStatements.length > 0) {
+            console.log(chalk.cyan(`[i] Writing ${indexStatements.length} non-module statements to index.js`));
+            const transformed = transformIndexStatements(indexStatements, mergedLibMap.size > 0 ? mergedLibMap : undefined);
+            const indexCode = validateAndFix(transformed, "index");
+            if (indexCode !== null)
+                files["index"] = indexCode;
         }
     }
-    return null;
-};
+    return { files, libModuleMap };
+});
 export default refactorReact;
 //# sourceMappingURL=index.js.map