@scriptc/compiler 0.3.5 → 0.4.0

package/dist/frontend/npm-static-rewrite-syntax.js

@@ -1,6 +1,56 @@
 import * as ts from "./ts7/syntax.js";
 import { bareRequireSpecOf, cjsLexedExportsOfFile, isExportsIdent, isModuleExports, } from "./cjs-syntax.js";
 import { rewriteBundledFunctionImports } from "./npm-static-bundled-cjs.js";
+import { getTextOfNode, tokenStartOfNode } from "./ts7/node-functions.js";
+/** True when esbuild's export object (`module.exports = __toCommonJS(T)`
+ * over a getter table `__export(T, {...})`) is installed before anything
+ * that can run another module's code, and nothing else writes the export
+ * object. Every statement before the installation is then a declaration,
+ * a directive, or the getter-table call (whose getters run only when
+ * read), and variable initializers evaluate no calls outside function
+ * bodies. The getters read live bindings, so the object a cycle partner
+ * captures early answers every later read exactly like the final table. */
+function liveExportTableFirst(sf, installAt, target, exportTables) {
+    if (!exportTables.some((t) => t.target === target))
+        return false;
+    let callsOutsideFunctions = false;
+    const noCalls = (root) => {
+        callsOutsideFunctions = false;
+        ts.walkPreorder(root, (n) => {
+            if (callsOutsideFunctions)
+                return "stop";
+            if (ts.isArrowFunction(n) || ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n))
+                return "skip";
+            if (ts.isCallExpression(n) || ts.isNewExpression(n) || ts.isTaggedTemplateExpression(n))
+                callsOutsideFunctions = true;
+            return undefined;
+        });
+        return !callsOutsideFunctions;
+    };
+    let sawTable = false;
+    for (const stmt of sf.statements.nodes) {
+        if (tokenStartOfNode(stmt) >= installAt)
+            return sawTable;
+        if (ts.isFunctionDeclaration(stmt) || ts.isEmptyStatement(stmt))
+            continue;
+        if (ts.isExpressionStatement(stmt) && ts.isStringLiteral(stmt.expression))
+            continue;
+        if (ts.isVariableStatement(stmt)) {
+            if (stmt.declarationList.declarations.nodes.every((d) => ts.isIdentifier(d.name) && (d.initializer === undefined || noCalls(d.initializer))))
+                continue;
+            return false;
+        }
+        if (ts.isExpressionStatement(stmt) && ts.isCallExpression(stmt.expression)) {
+            const table = exportCallOf(stmt.expression);
+            if (table !== null && table.target === target) {
+                sawTable = true;
+                continue;
+            }
+        }
+        return false;
+    }
+    return false;
+}
 export function isBundlerCjsCandidate(source) {
     return (source.includes("__toCommonJS") ||
         source.includes("__toESM") ||
@@ -8,16 +58,29 @@ export function isBundlerCjsCandidate(source) {
         source.includes("__reExport") ||
         (source.includes("Object.defineProperty(exports") && source.includes("get")));
 }
+/** The helper a bundler-emitted name spells. esbuild suffixes a helper
+ * that a bundled module declares again with a counter (a bundled esbuild
+ * dist inside another bundle carries `__export2`, `__toCommonJS2`, …); the
+ * recognizers below verify each call's shape, so the counter carries no
+ * meaning beyond the name collision it avoided. */
+export function bundlerHelperBase(name) {
+    return /^__[A-Za-z]+\d+$/.test(name) ? name.replace(/\d+$/, "") : name;
+}
 /** The last NAME of a callee: bare identifier or any member chain's final
- * name (`tslib_1.__exportStar` → "__exportStar"). */
+ * name (`tslib_1.__exportStar` → "__exportStar"), helper counters dropped. */
 function calleeNameOf(call) {
     const callee = call.expression;
     if (ts.isIdentifier(callee))
-        return callee.text;
+        return bundlerHelperBase(callee.text);
     if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.name))
-        return callee.name.text;
+        return bundlerHelperBase(callee.name.text);
     return null;
 }
+/** True for an identifier spelling the named helper (counter-suffixed
+ * spellings included). */
+function isHelperIdent(node, base) {
+    return ts.isIdentifier(node) && bundlerHelperBase(node.text) === base;
+}
 /** A chaseable getter/descriptor VALUE: a plain identifier, an
  * identifier-rooted member/element chain (string keys only), or a scalar
  * literal. Answers the classification or null (not chaseable). */
@@ -33,7 +96,7 @@ function chaseValue(e) {
         cur.kind === ts.SyntaxKind.TrueKeyword ||
         cur.kind === ts.SyntaxKind.FalseKeyword ||
         cur.kind === ts.SyntaxKind.NullKeyword) {
-        return { kind: "hoist", text: cur.getText() };
+        return { kind: "hoist", text: getTextOfNode(cur) };
     }
     // ident-rooted member chains: this.x / a.b.c / a["k"].d — side-effect
     // free reads the tail const can evaluate once.
@@ -47,19 +110,38 @@ function chaseValue(e) {
         walk = walk.expression;
     }
     if (ts.isIdentifier(walk))
-        return { kind: "hoist", text: cur.getText() };
+        return { kind: "hoist", text: getTextOfNode(cur) };
     return null;
 }
+/** An object literal of side-effect-free member values (`exports.default
+ * = { context: context_api_1.context, metrics: metrics_api_1.metrics }`,
+ * tsc's default-export object): the tail const can build it once, like a
+ * chased value. Null for any other shape (spreads, methods, accessors,
+ * computed keys, or a value chaseValue rejects). */
+function chaseObjectLiteral(e) {
+    let cur = e;
+    while (ts.isParenthesizedExpression(cur))
+        cur = cur.expression;
+    if (!ts.isObjectLiteralExpression(cur))
+        return null;
+    for (const prop of cur.properties.nodes) {
+        if (!ts.isPropertyAssignment(prop) ||
+            !(ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) ||
+            (chaseValue(prop.initializer) === null && chaseObjectLiteral(prop.initializer) === null))
+            return null;
+    }
+    return { kind: "hoist", text: getTextOfNode(cur) };
+}
 /** The getter body's returned expression for the two descriptor getter
  * spellings (`get() { return X }` / `get: function () { return X }`) and
  * the arrow forms the esbuild table uses (`() => X`, `() => { return X }`). */
 function getterReturnOf(fn) {
     let body;
-    if (ts.isArrowFunction(fn) && fn.parameters.length === 0)
+    if (ts.isArrowFunction(fn) && fn.parameters.nodes.length === 0)
         body = fn.body;
-    else if (ts.isFunctionExpression(fn) && fn.parameters.length === 0)
+    else if (ts.isFunctionExpression(fn) && fn.parameters.nodes.length === 0)
         body = fn.body;
-    else if (ts.isMethodDeclaration(fn) && fn.parameters.length === 0 && fn.body !== undefined)
+    else if (ts.isMethodDeclaration(fn) && fn.parameters.nodes.length === 0 && fn.body !== undefined)
         body = fn.body;
     else
         return null;
@@ -67,9 +149,9 @@ function getterReturnOf(fn) {
         return null;
     if (!ts.isBlock(body))
         return body; // expression-bodied arrow
-    if (body.statements.length !== 1)
+    if (body.statements.nodes.length !== 1)
         return null;
-    const ret = body.statements[0];
+    const ret = body.statements.nodes[0];
     return ts.isReturnStatement(ret) && ret.expression !== undefined ? ret.expression : null;
 }
 /** The `__export(IDENT, { name: () => value, ... })` call's parts, or null.
@@ -78,13 +160,13 @@ function getterReturnOf(fn) {
 function exportCallOf(call) {
     if (calleeNameOf(call) !== "__export")
         return null;
-    if (call.arguments.length !== 2)
+    if (call.arguments.nodes.length !== 2)
         return null;
-    const [target, table] = call.arguments;
+    const [target, table] = call.arguments.nodes;
     if (!ts.isIdentifier(target) || !ts.isObjectLiteralExpression(table))
         return null;
     const entries = [];
-    for (const prop of table.properties) {
+    for (const prop of table.properties.nodes) {
         if (!ts.isPropertyAssignment(prop))
             return null;
         let name;
@@ -111,16 +193,16 @@ function definePropertyExportOf(call) {
         callee.name.text !== "defineProperty") {
         return null;
     }
-    if (call.arguments.length !== 3)
+    if (call.arguments.nodes.length !== 3)
         return null;
-    const [recv, nameArg, desc] = call.arguments;
+    const [recv, nameArg, desc] = call.arguments.nodes;
     if (!isExportsIdent(recv) && !isModuleExports(recv))
         return null;
     if (!ts.isStringLiteral(nameArg) || !ts.isObjectLiteralExpression(desc))
         return null;
     const name = nameArg.text;
     let value = null;
-    for (const p of desc.properties) {
+    for (const p of desc.properties.nodes) {
         if (ts.isPropertyAssignment(p) && ts.isIdentifier(p.name)) {
             if (p.name.text === "value")
                 value = p.initializer;
@@ -156,24 +238,18 @@ function isPlainName(name) {
  * __copyProps(…, mod) call copying onto a conditional that tests
  * isNodeMode/__esModule and defines "default" with value mod. Comments and
  * formatting are free; the SHAPE is the contract. */
-function recognizedToEsmDecl(stmt) {
-    if (!ts.isVariableStatement(stmt))
-        return false;
-    const decls = stmt.declarationList.declarations;
-    if (decls.length !== 1)
-        return false;
-    const d = decls[0];
-    if (!ts.isIdentifier(d.name) || d.name.text !== "__toESM" || d.initializer === undefined)
+function recognizedToEsmDecl(d) {
+    if (!isHelperIdent(d.name, "__toESM") || d.initializer === undefined)
         return false;
     let init = d.initializer;
     while (ts.isParenthesizedExpression(init))
         init = init.expression;
     if (!ts.isArrowFunction(init))
         return false;
-    if (init.parameters.length < 2 || init.parameters.length > 3)
+    if (init.parameters.nodes.length < 2 || init.parameters.nodes.length > 3)
         return false;
-    const p0 = init.parameters[0];
-    const p1 = init.parameters[1];
+    const p0 = init.parameters.nodes[0];
+    const p1 = init.parameters.nodes[1];
     if (!ts.isIdentifier(p0.name) || !ts.isIdentifier(p1.name))
         return false;
     const mod = p0.name.text;
@@ -189,39 +265,35 @@ function recognizedToEsmDecl(stmt) {
     }
     while (ts.isParenthesizedExpression(expr))
         expr = expr.expression;
-    if (!ts.isCallExpression(expr) ||
-        !ts.isIdentifier(expr.expression) ||
-        expr.expression.text !== "__copyProps")
+    if (!ts.isCallExpression(expr) || !isHelperIdent(expr.expression, "__copyProps"))
         return false;
-    if (expr.arguments.length < 2)
+    if (expr.arguments.nodes.length < 2)
         return false;
-    const from = expr.arguments[1];
+    const from = expr.arguments.nodes[1];
     if (!ts.isIdentifier(from) || from.text !== mod)
         return false;
-    let to = expr.arguments[0];
+    let to = expr.arguments.nodes[0];
     while (ts.isParenthesizedExpression(to))
         to = to.expression;
     if (!ts.isConditionalExpression(to))
         return false;
-    const condText = to.condition.getText();
+    const condText = getTextOfNode(to.condition);
     if (!condText.includes(isNodeMode) || !condText.includes("__esModule"))
         return false;
     let stamp = to.whenTrue;
     while (ts.isParenthesizedExpression(stamp))
         stamp = stamp.expression;
-    if (!ts.isCallExpression(stamp) ||
-        !ts.isIdentifier(stamp.expression) ||
-        stamp.expression.text !== "__defProp")
+    if (!ts.isCallExpression(stamp) || !isHelperIdent(stamp.expression, "__defProp"))
         return false;
-    if (stamp.arguments.length !== 3)
+    if (stamp.arguments.nodes.length !== 3)
         return false;
-    const nameArg = stamp.arguments[1];
+    const nameArg = stamp.arguments.nodes[1];
     if (!ts.isStringLiteral(nameArg) || nameArg.text !== "default")
         return false;
-    const desc = stamp.arguments[2];
+    const desc = stamp.arguments.nodes[2];
     if (!ts.isObjectLiteralExpression(desc))
         return false;
-    return desc.properties.some((p) => ts.isPropertyAssignment(p) &&
+    return desc.properties.nodes.some((p) => ts.isPropertyAssignment(p) &&
         ts.isIdentifier(p.name) &&
         p.name.text === "value" &&
         ts.isIdentifier(p.initializer) &&
@@ -244,14 +316,28 @@ function planToEsmInterop(sf, filePath, host) {
         moduleBindings: new Set(),
         degrade: reason,
     });
-    const declStmts = sf.statements.filter((s) => ts.isVariableStatement(s) &&
-        s.declarationList.declarations.some((d) => ts.isIdentifier(d.name) && d.name.text === "__toESM"));
+    // Top-level declarators of the helper, any statement shape (minified
+    // dists share one `var` among several helpers), by spelling.
+    const decls = new Map();
+    for (const s of sf.statements.nodes) {
+        if (!ts.isVariableStatement(s))
+            continue;
+        for (const d of s.declarationList.declarations.nodes) {
+            if (!isHelperIdent(d.name, "__toESM"))
+                continue;
+            const list = decls.get(d.name.text);
+            if (list === undefined)
+                decls.set(d.name.text, [d]);
+            else
+                list.push(d);
+        }
+    }
     const refs = [];
     const calls = [];
     const collect = (n) => {
-        if (ts.isIdentifier(n) && n.text === "__toESM")
+        if (isHelperIdent(n, "__toESM"))
             refs.push(n);
-        if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === "__toESM")
+        if (ts.isCallExpression(n) && isHelperIdent(n.expression, "__toESM"))
             calls.push(n);
     };
     ts.walkPreorder(sf, collect);
@@ -261,29 +347,31 @@ function planToEsmInterop(sf, filePath, host) {
     // a helper that escapes as a VALUE is outside the recognized shape.
     const callees = new Set(calls.map((c) => c.expression));
     const declNames = new Set();
-    for (const s of declStmts) {
-        for (const d of s.declarationList.declarations) {
-            if (ts.isIdentifier(d.name) && d.name.text === "__toESM")
-                declNames.add(d.name);
-        }
-    }
+    for (const list of decls.values())
+        for (const d of list)
+            declNames.add(d.name);
     if (refs.some((r) => !callees.has(r) && !declNames.has(r)))
         return fail(TO_ESM_ESCAPE_DEGRADE);
     if (calls.length === 0)
         return plan; // declared but never called — dead helper
-    if (declStmts.length !== 1 || !recognizedToEsmDecl(declStmts[0]))
-        return fail(TO_ESM_SHAPE_DEGRADE);
+    // Every spelling a call uses must be declared exactly once, in the
+    // recognized shape.
+    for (const call of calls) {
+        const list = decls.get(call.expression.text);
+        if (list === undefined || list.length !== 1 || !recognizedToEsmDecl(list[0]))
+            return fail(TO_ESM_SHAPE_DEGRADE);
+    }
     /** Module-scope interop bindings: name → whether `.default` IS the
      * module (pad the access) rather than a member read of its `default`. */
     const bindings = new Map();
     for (const call of calls) {
-        const arg0 = call.arguments[0];
+        const arg0 = call.arguments.nodes[0];
         const spec = arg0 !== undefined ? bareRequireSpecOf(arg0) : null;
-        if (spec === null || call.arguments.length > 2)
+        if (spec === null || call.arguments.nodes.length > 2)
             return fail(TO_ESM_ARG_DEGRADE);
         let isNodeMode = false;
-        if (call.arguments.length === 2) {
-            const modeArg = call.arguments[1];
+        if (call.arguments.nodes.length === 2) {
+            const modeArg = call.arguments.nodes[1];
             if (ts.isNumericLiteral(modeArg))
                 isNodeMode = Number(modeArg.text) !== 0;
             else if (modeArg.kind === ts.SyntaxKind.TrueKeyword)
@@ -317,7 +405,7 @@ function planToEsmInterop(sf, filePath, host) {
             if (parent.name.text === "default" && defaultIsModule) {
                 if (!readOnlyAccess(parent))
                     return fail(TO_ESM_ESCAPE_DEGRADE);
-                pads.push({ start: child.getEnd(), end: parent.getEnd() });
+                pads.push({ start: child.end, end: parent.end });
             }
         }
         else {
@@ -326,8 +414,8 @@ function planToEsmInterop(sf, filePath, host) {
         // the wrapper itself: callee + '(' down, and everything after the
         // require argument (`, 1` included) — the bare require survives at its
         // original offsets.
-        pads.push({ start: call.getStart(sf), end: arg0.getStart(sf) });
-        pads.push({ start: arg0.getEnd(), end: call.getEnd() });
+        pads.push({ start: tokenStartOfNode(call), end: tokenStartOfNode(arg0) });
+        pads.push({ start: arg0.end, end: call.end });
     }
     if (bindings.size > 0) {
         // Binding safety: the erased binding must be declared exactly once and
@@ -382,7 +470,7 @@ function planToEsmInterop(sf, filePath, host) {
                     violated = true;
                     return;
                 }
-                pads.push({ start: n.expression.getEnd(), end: n.getEnd() });
+                pads.push({ start: n.expression.end, end: n.end });
             }
         };
         ts.walkPreorder(sf, padDefaults);
@@ -423,16 +511,22 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
         return null;
     // ESM bundles can contain closed CommonJS function factories. Recognize
     // those before refusing interop that needs a dynamic module namespace.
-    if (ts.isExternalModule(sf)) {
+    // TypeScript forces every `.cjs` file to be an external module
+    // (isFileForcedToBeModuleByFormat), yet Node always loads one as
+    // CommonJS: the extension, not that flag, decides the format there.
+    if (!filePath.endsWith(".cjs") && ts.isExternalModule(sf)) {
         const bundled = rewriteBundledFunctionImports(source, sf);
         if (bundled !== null)
             return bundled;
-        return source.includes("__toESM(")
-            ? {
-                degrade: "its ES-module dist routes an external dependency through the __toESM " +
+        if (!source.includes("__toESM("))
+            return null;
+        return {
+            degrade: source.includes("__commonJS")
+                ? "its ES-module bundle reaches bundled CommonJS modules through the __commonJS and " +
+                    "__toESM bundler-interop helpers, which cannot compile natively in ESM output"
+                : "its ES-module dist routes an external dependency through the __toESM " +
                     "bundler-interop helper, which cannot compile natively in ESM output",
-            }
-            : null;
+        };
     }
     // The __toESM interop pass (see the section header): wrapper call sites
     // pad down to the bare require they wrap, module-valued `.default`
@@ -454,7 +548,7 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
         if (!starSpecsInOrder.includes(spec))
             starSpecsInOrder.push(spec);
     };
-    for (const stmt of sf.statements) {
+    for (const stmt of sf.statements.nodes) {
         if (!ts.isExpressionStatement(stmt))
             continue;
         const e = stmt.expression;
@@ -465,11 +559,11 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
             const rhs = e.right;
             if (ts.isCallExpression(rhs) &&
                 calleeNameOf(rhs) === "__toCommonJS" &&
-                rhs.arguments.length === 1 &&
-                ts.isIdentifier(rhs.arguments[0])) {
-                esbuildMainTarget = rhs.arguments[0].text;
-                tablePos = stmt.getStart(sf);
-                neutralize.push({ start: stmt.getStart(sf), end: stmt.getEnd() });
+                rhs.arguments.nodes.length === 1 &&
+                ts.isIdentifier(rhs.arguments.nodes[0])) {
+                esbuildMainTarget = rhs.arguments.nodes[0].text;
+                tablePos = tokenStartOfNode(stmt);
+                neutralize.push({ start: tokenStartOfNode(stmt), end: stmt.end });
                 sawBundleShape = true;
                 continue;
             }
@@ -501,9 +595,9 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
                     names,
                     finalRhs: cur,
                     viaBareExports,
-                    pos: stmt.getStart(sf),
-                    start: stmt.getStart(sf),
-                    end: stmt.getEnd(),
+                    pos: tokenStartOfNode(stmt),
+                    start: tokenStartOfNode(stmt),
+                    end: stmt.end,
                 });
                 continue; // classified later (only when a rewrite actually happens)
             }
@@ -520,7 +614,7 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
                 inner.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
                 isModuleExports(inner.left) &&
                 ts.isObjectLiteralExpression(inner.right)) {
-                neutralize.push({ start: stmt.getStart(sf), end: stmt.getEnd() });
+                neutralize.push({ start: tokenStartOfNode(stmt), end: stmt.end });
                 sawBundleShape = true;
                 continue;
             }
@@ -532,28 +626,28 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
         const table = exportCallOf(e);
         if (table !== null) {
             exportTables.push(table);
-            neutralize.push({ start: stmt.getStart(sf), end: stmt.getEnd() });
+            neutralize.push({ start: tokenStartOfNode(stmt), end: stmt.end });
             sawBundleShape = true;
             continue;
         }
         // `__exportStar(require('spec'), exports);` — the tsc/tslib spelling —
         // and `__export(require('spec'))`, the legacy twin.
-        if ((name === "__exportStar" || name === "__export") && e.arguments.length >= 1) {
-            const spec = bareRequireSpecOf(e.arguments[0]);
+        if ((name === "__exportStar" || name === "__export") && e.arguments.nodes.length >= 1) {
+            const spec = bareRequireSpecOf(e.arguments.nodes[0]);
             if (spec !== null) {
                 addStarSpec(spec);
-                neutralize.push({ start: stmt.getStart(sf), end: stmt.getEnd() });
+                neutralize.push({ start: tokenStartOfNode(stmt), end: stmt.end });
                 sawBundleShape = true;
                 continue;
             }
         }
         // `__reExport(TARGET, require('spec')[, module.exports]);` — esbuild's
         // `export * from` plumbing.
-        if (name === "__reExport" && e.arguments.length >= 2) {
-            const spec = bareRequireSpecOf(e.arguments[1]);
+        if (name === "__reExport" && e.arguments.nodes.length >= 2) {
+            const spec = bareRequireSpecOf(e.arguments.nodes[1]);
             if (spec !== null) {
                 addStarSpec(spec);
-                neutralize.push({ start: stmt.getStart(sf), end: stmt.getEnd() });
+                neutralize.push({ start: tokenStartOfNode(stmt), end: stmt.end });
                 sawBundleShape = true;
                 continue;
             }
@@ -562,7 +656,7 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
         const def = definePropertyExportOf(e);
         if (def !== null) {
             if (def.esModuleStamp) {
-                neutralize.push({ start: stmt.getStart(sf), end: stmt.getEnd() });
+                neutralize.push({ start: tokenStartOfNode(stmt), end: stmt.end });
                 // the canonical table re-stamps it (lexer-visibly — merve detects
                 // this defineProperty form, so parity wants a visible entry)
                 continue;
@@ -570,7 +664,7 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
             const chased = def.value !== null ? chaseValue(def.value) : null;
             if (chased !== null) {
                 definePropEntries.push({ name: def.name, value: def.value });
-                neutralize.push({ start: stmt.getStart(sf), end: stmt.getEnd() });
+                neutralize.push({ start: tokenStartOfNode(stmt), end: stmt.end });
                 sawBundleShape = true;
             }
             // unchaseable descriptor: LEAVE the statement (its runtime fence
@@ -580,6 +674,16 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
         }
     }
     const lexed = cjsLexedExportsOfFile(sf);
+    if (host.requireOnly?.(filePath) === true) {
+        for (const t of exportTables)
+            for (const [name] of t.entries)
+                lexed.exports.add(name);
+        for (const d of definePropEntries)
+            lexed.exports.add(d.name);
+        for (const m of memberStmts)
+            for (const name of m.names)
+                lexed.exports.add(name);
+    }
     let emitTable = sawBundleShape && (lexed.exports.size > 0 || lexed.reexports.length > 0);
     const starSpecs = [];
     const entries = new Map();
@@ -620,8 +724,15 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
             ...exportTables.filter((t) => t.target !== esbuildMainTarget),
         ];
         for (const t of tablesOrdered) {
-            for (const [name, value] of t.entries)
-                claim(name, classify(name, value));
+            for (const [name, value] of t.entries) {
+                const spec = classify(name, value);
+                // The table feeding module.exports keeps a getter it cannot chase
+                // as a live accessor rather than a snapshot.
+                if (spec.kind === "any" && value !== null && t.target === esbuildMainTarget)
+                    claim(name, { name, kind: "getter", value: getTextOfNode(value) });
+                else
+                    claim(name, spec);
+            }
         }
         for (const d of definePropEntries)
             claim(d.name, classify(d.name, d.value));
@@ -653,7 +764,7 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
                 // anything else keeps the file untouched (the offender path owns
                 // it: neutralizing would drop an evaluation, keeping it meets the
                 // lowering's discard fence at load).
-                const chased = chaseValue(cur);
+                const chased = chaseValue(cur) ?? chaseObjectLiteral(cur);
                 if (chased === null) {
                     return toEsm.pads.length > 0 ? { degrade: TO_ESM_MIXED_DEGRADE } : null;
                 }
@@ -672,14 +783,14 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
          * fence the whole statement). Everything else snapshots via a tail
          * const. */
         const immutableTopLevel = new Set();
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             if (ts.isFunctionDeclaration(stmt) && stmt.name !== undefined)
                 immutableTopLevel.add(stmt.name.text);
             else if (ts.isClassDeclaration(stmt) && stmt.name !== undefined)
                 immutableTopLevel.add(stmt.name.text);
             else if (ts.isVariableStatement(stmt) &&
                 (stmt.declarationList.flags & ts.NodeFlags.Const) !== 0) {
-                for (const d of stmt.declarationList.declarations) {
+                for (const d of stmt.declarationList.declarations.nodes) {
                     if (ts.isIdentifier(d.name))
                         immutableTopLevel.add(d.name.text);
                 }
@@ -751,23 +862,37 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
             "__reExport",
             "__toESM",
             "__toCommonJS",
+            "__commonJS",
+            "__esm",
             "__exportStar",
             "__createBinding",
             "__setModuleDefault",
             "__importStar",
             "__importDefault",
         ]);
+        /* Helper declarators by name. A minified dist shares one `var` among
+         * several helpers (`var __getProtoOf=…,__hasOwnProp=…;`): each
+         * declarator is its own candidate, and the statement pads whole only
+         * once every declarator in it is dead. */
         const helperDecls = new Map();
-        for (const stmt of sf.statements) {
+        const helperStmts = [];
+        for (const stmt of sf.statements.nodes) {
             if (!ts.isVariableStatement(stmt))
                 continue;
-            const decls = stmt.declarationList.declarations;
-            if (decls.length !== 1)
-                continue;
-            const d = decls[0];
-            if (ts.isIdentifier(d.name) && HELPER_NAMES.has(d.name.text)) {
-                helperDecls.set(d.name.text, { start: stmt.getStart(sf), end: stmt.getEnd() });
+            const decls = stmt.declarationList.declarations.nodes;
+            let anyHelper = false;
+            for (const d of decls) {
+                if (!ts.isIdentifier(d.name) || !HELPER_NAMES.has(bundlerHelperBase(d.name.text)))
+                    continue;
+                if (helperDecls.has(d.name.text))
+                    continue; // redeclared: keep the first, never sweep twice
+                anyHelper = true;
+                helperDecls.set(d.name.text, decls.length === 1
+                    ? { start: tokenStartOfNode(stmt), end: stmt.end }
+                    : { start: tokenStartOfNode(d), end: d.end });
             }
+            if (anyHelper && decls.length > 1)
+                helperStmts.push(stmt);
         }
         // every identifier occurrence of a helper name outside its own
         // declarator name node, position-recorded for the span test
@@ -779,9 +904,9 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
                     return;
                 const list = refs.get(node.text);
                 if (list === undefined)
-                    refs.set(node.text, [node.getStart(sf)]);
+                    refs.set(node.text, [tokenStartOfNode(node)]);
                 else
-                    list.push(node.getStart(sf));
+                    list.push(tokenStartOfNode(node));
             }
         };
         ts.walkPreorder(sf, record);
@@ -804,8 +929,40 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
                 }
             }
         }
+        // A swept declarator of a shared statement pads with its separating
+        // comma, and the statement pads whole once every declarator is dead:
+        // padding the bare declarator span would leave a dangling comma.
+        const declaratorSpans = new Set();
+        const declaratorPads = [];
+        for (const stmt of helperStmts) {
+            const decls = stmt.declarationList.declarations.nodes;
+            const deadAt = decls.map((d) => {
+                if (!ts.isIdentifier(d.name) || !removed.has(d.name.text))
+                    return false;
+                const span = helperDecls.get(d.name.text);
+                if (span.start !== tokenStartOfNode(d))
+                    return false;
+                declaratorSpans.add(span);
+                return true;
+            });
+            if (deadAt.every((x) => x)) {
+                declaratorPads.push({ start: tokenStartOfNode(stmt), end: stmt.end });
+                continue;
+            }
+            // Dead declarators before the last live one take their trailing
+            // comma; the dead tail after it pads from that declarator's end.
+            const lastLive = deadAt.lastIndexOf(false);
+            for (let i = 0; i < decls.length; i++) {
+                if (!deadAt[i])
+                    continue;
+                const d = decls[i];
+                declaratorPads.push(i < lastLive
+                    ? { start: tokenStartOfNode(d), end: tokenStartOfNode(decls[i + 1]) }
+                    : { start: decls[lastLive].end, end: d.end });
+            }
+        }
         neutralize.length = 0;
-        neutralize.push(...dead);
+        neutralize.push(...dead.filter((span) => !declaratorSpans.has(span)), ...declaratorPads);
     }
     /* ── emission ─────────────────────────────────────────────────────── */
     let text = source;
@@ -815,6 +972,12 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
     }
     if (!emitTable)
         return text; // interop pads only — nothing appends
+    if (esbuildMainTarget !== null &&
+        tablePos !== null &&
+        memberStmts.length === 0 &&
+        definePropEntries.length === 0 &&
+        liveExportTableFirst(sf, tablePos, esbuildMainTarget, exportTables))
+        host.liveExportTable?.(filePath);
     const lines = [""];
     const hasAnyFallback = [...entries.values()].some((s) => s.kind === "any");
     if (hasAnyFallback) {
@@ -848,6 +1011,9 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
             hoists.push(`const ${v} = ${dropInteropDefault(spec.value)};`);
             plainParts.push(`${keyOf(spec.name)}: ${v},`);
         }
+        else if (spec.kind === "getter") {
+            plainParts.push(`get ${keyOf(spec.name)}() { return ${dropInteropDefault(spec.value)}; },`);
+        }
         else {
             plainParts.push(`${keyOf(spec.name)}: __scriptc_any,`);
         }
@@ -868,6 +1034,13 @@ export function rewriteBundlerCjsSyntax(sf, filePath, host) {
     const esModulePart = lexed.exports.has("__esModule") ? "__esModule: true," : "";
     const memberParts = starMembers.map((m) => `${keyOf(m.name)}: ${m.ref}${isPlainName(m.name) ? `.${m.name}` : `[${JSON.stringify(m.name)}]`},`);
     lines.push(`module.exports = {${spreadParts.join("")}${plainParts.join("")}${esModulePart}${memberParts.join("")}};`);
+    /* Node's lexer skips accessors (and stops reading an object literal at
+     * the first one), so a canonical table with accessor entries hides
+     * names the original showed it (esbuild's dead annotation): the host
+     * keeps the original's lexer answer, so ES-module importers link
+     * exactly as they do against the original. */
+    if ([...entries.values()].some((spec) => spec.kind === "getter"))
+        host.lexerVisibleNames?.(filePath, [...lexed.exports]);
     return text + lines.join("\n") + "\n";
 }
 //# sourceMappingURL=npm-static-rewrite-syntax.js.map