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

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,225 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var _a;
 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";
+import { cs_mast_init } from "@shriyanss/cs-mast";
+import { isInModuleMap } from "./helpers.js";
+import { validateAndFix } from "./validator.js";
+import { transformModule, transformIndexStatements } from "./transform.js";
+import { classifyLibraryModule, resolveReexportChains } from "./library-classify.js";
 const traverse = _traverse.default;
-const generate = _generator.default;
+const generate = (_a = _generator.default) !== null && _a !== void 0 ? _a : _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 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.
- *
- * 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>(...)`).
+ * Rewrites a webpack-bundled React chunk by splitting the numeric module map
+ * into individual ECMAScript module files.
  *
- * 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));
+// 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 module's body
+// matches a baseline library signature.
+const moduleIsLibrary = (mod, libSigs) => {
+    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: LIB_SIG_SCAT,
+            sinc: [],
+            lang: "js",
+            prsr: "@babel/parser",
+        });
+        for (const sig of tree._signatureMap.keys()) {
+            if (isLibrarySig(sig, libSigs))
+                return true;
+        }
+    }
+    catch (_a) {
+        // unparseable / unhashable — fall through and treat as non-library
+    }
+    return false;
+};
+const refactorReact = (chunk, libSigs) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    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 m = params[0], e = params[1], r = params.length >= 3 ? params[2] : undefined;
-        if (!t.isIdentifier(m) || !t.isIdentifier(e))
+        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 (r !== undefined && !t.isIdentifier(r))
+        }
+        const value = path.node.value;
+        if (!t.isFunctionExpression(value) && !t.isArrowFunctionExpression(value))
             return;
+        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;
-                            }
-                        }
-                    }
-                },
-            },
-        });
-    }
-    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))
-                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 });
-            }
+    console.log(chalk.cyan(`[i] Found ${modules.length} modules`));
+    const results = {};
+    // moduleId → LibraryModuleInfo for modules that are library-classified
+    const libModuleMap = new Map();
+    let libraryCount = 0;
+    for (const mod of modules) {
+        if (moduleIsLibrary(mod, libSigs)) {
+            console.log(chalk.gray(`[-] Module ${mod.id} matches library baseline — skipping`));
+            libraryCount++;
+            // Classify the library module so index.js can use proper named imports
+            const info = classifyLibraryModule(mod);
+            libModuleMap.set(mod.id, info);
+            continue;
         }
-        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} };`);
+        const statements = transformModule(mod);
+        const code = validateAndFix(statements, mod.id);
+        if (code === null) {
+            console.log(chalk.yellow(`[~] Module ${mod.id} skipped due to unresolvable syntax errors`));
+            continue;
         }
-        parts.push(...defaultLines);
-        if (parts.length > 0)
-            trailingExports = `\n\n${parts.join("\n")}`;
+        results[mod.id] = code;
     }
-    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};`;
+    if (libSigs && libSigs.size > 0) {
+        console.log(chalk.cyan(`[i] Library modules skipped: ${libraryCount}/${modules.length}`));
+        // Resolve re-export chains so shim modules (e.g. 540 → 287/React) get the right identity
+        resolveReexportChains(libModuleMap, modules);
     }
-    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);
-    }
-    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);
-            }
+    // Collect everything in the IIFE body that is NOT the module-map variable into index.js.
+    const topLevel = (_a = findIifeBody(ast.program)) !== null && _a !== void 0 ? _a : 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));
         }
-    }
-    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;
-                }
-            }
+        else {
+            indexStatements.push(stmt);
         }
     }
-    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;
-            }
-        }
+    if (indexStatements.length > 0) {
+        console.log(chalk.cyan(`[i] Writing ${indexStatements.length} non-module statements to index.js`));
+        const transformed = transformIndexStatements(indexStatements, libModuleMap.size > 0 ? libModuleMap : undefined);
+        const indexCode = validateAndFix(transformed, "index");
+        if (indexCode !== null)
+            results["index"] = indexCode;
     }
-    return null;
-};
+    return results;
+});
 export default refactorReact;
 //# sourceMappingURL=index.js.map