@wular/pnext 0.0.4 → 0.0.6

package/src/compat/bundler/cjs-exports.ts

@@ -1,29 +1,29 @@
-import type { Plugin } from 'esbuild';
-import { readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { dirname, extname, isAbsolute } from 'node:path';
+import type { Plugin } from 'esbuild'
+import { readFileSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { dirname, extname, isAbsolute } from 'node:path'
 
 import {
   isCommonJsModuleSource,
   providedEntryResolution,
   resolveLinkedPackageSpecifier,
   resolveRuntimeSpecifier,
-} from '../../resolve/imports';
-import { rewriteFacts } from '../../resolve/scan-facts';
-import { spliceSource } from '../../dev/module-transform';
-import { clientReferenceId } from '../../client/reference';
-import { hasUseClientDirective } from '../../client/reference-stub';
-import { isIdentifier, uniqueIdentifier } from '../../utils/source';
-import { fileMemo, fileMemoAsync } from './source-cache';
+} from '../../resolve/imports'
+import { rewriteFacts } from '../../resolve/scan-facts'
+import { spliceSource } from '../../runtime/module-transform'
+import { clientReferenceId } from '../../client/reference'
+import { hasUseClientDirective } from '../../client/reference-stub'
+import { isIdentifier, uniqueIdentifier } from '../../utils/code'
+import { fileMemo, fileMemoAsync } from './source-cache'
 
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
 
 // esbuild treats a CommonJS entry point as `module.exports`, bypassing its
 // normal `__esModule` default-import interop. Route CJS package entries through
 // a JavaScript ESM facade so Babel/TypeScript-shaped modules expose
 // `exports.default`, while ordinary CJS continues to expose `module.exports`.
-const interopEntryPrefix = 'pnext-cjs-interop:';
+const interopEntryPrefix = 'pnext-cjs-interop:'
 
 /**
  * Entry-point CJS classification, done ONCE where the caller already knows the entry - the marker keeps
@@ -36,9 +36,9 @@ export function commonJsInteropEntry(
   resolved?: string,
 ): string | undefined {
   const classified =
-    resolved ?? (isAbsolute(specifier) ? specifier : resolveEntryPath(specifier, resolveDir));
-  if (!classified || !isCommonJsJavaScriptFile(classified)) return undefined;
-  return interopEntryPrefix + specifier;
+    resolved ?? (isAbsolute(specifier) ? specifier : resolveEntryPath(specifier, resolveDir))
+  if (!classified || !isCommonJsJavaScriptFile(classified)) return undefined
+  return interopEntryPrefix + specifier
 }
 
 export function commonJsDefaultInteropPlugin(): Plugin {
@@ -46,29 +46,29 @@ export function commonJsDefaultInteropPlugin(): Plugin {
     name: 'pnext-cjs-default-interop',
     setup(build) {
       build.onResolve({ filter: /^pnext-cjs-interop:/ }, args => {
-        const source = args.path.slice(interopEntryPrefix.length);
+        const source = args.path.slice(interopEntryPrefix.length)
         const resolved = isAbsolute(source)
           ? source
-          : resolveEntryPath(source, args.resolveDir || process.cwd());
+          : resolveEntryPath(source, args.resolveDir || process.cwd())
         return {
           path: `${source}.pnext-cjs-default-interop.js`,
           namespace: 'pnext-cjs-default-interop',
           pluginData: { source, resolved: resolved ?? source },
-        };
-      });
+        }
+      })
       build.onLoad({ filter: /.*/, namespace: 'pnext-cjs-default-interop' }, args => {
-        const data = args.pluginData as { source?: string; resolved?: string } | undefined;
-        const source = data?.source ?? args.path;
+        const data = args.pluginData as { source?: string; resolved?: string } | undefined
+        const source = data?.source ?? args.path
         // The facade's `export default` alone breaks a consumer's named import
         // (`import { Network } from 'relay-runtime'`), so mirror the entry's
         // statically discoverable CommonJS keys as named exports too. Read them
         // from the *resolved* file — `source` may be a bare specifier.
-        const names = data?.resolved ? namedFacadeExportNames(data.resolved) : [];
-        const namespaceName = '__pnext_cjs_ns';
+        const names = data?.resolved ? namedFacadeExportNames(data.resolved) : []
+        const namespaceName = '__pnext_cjs_ns'
         const bindings = names.map((name, index) => ({
           name,
           localName: `__pnext_cjs_named_${index}`,
-        }));
+        }))
         return {
           contents: [
             `const value = require(${JSON.stringify(source)});`,
@@ -80,8 +80,8 @@ export function commonJsDefaultInteropPlugin(): Plugin {
             // is undefined). Read names off `value`, falling back to the
             // namespace for packages that expose them only under `.default`.
             ...bindings.map(({ name, localName }) => {
-              const key = JSON.stringify(name);
-              return `const ${localName} = value != null && value[${key}] !== undefined ? value[${key}] : (${namespaceName} == null ? undefined : ${namespaceName}[${key}]);`;
+              const key = JSON.stringify(name)
+              return `const ${localName} = value != null && value[${key}] !== undefined ? value[${key}] : (${namespaceName} == null ? undefined : ${namespaceName}[${key}]);`
             }),
             ...(bindings.length > 0
               ? [
@@ -97,10 +97,10 @@ export function commonJsDefaultInteropPlugin(): Plugin {
           // not walk up for node_modules from it; unscoped only worked by
           // accident ('pkg' -> '.'). Anchor on the resolved file.
           resolveDir: dirname(data?.resolved ?? source),
-        };
-      });
+        }
+      })
     },
-  };
+  }
 }
 
 /**
@@ -109,75 +109,73 @@ export function commonJsDefaultInteropPlugin(): Plugin {
  * client reference" after a full read the bundler then repeats itself.
  */
 export const clientReferenceLoad = fileMemoAsync(async (file: string) => {
-  let bytes: Buffer;
+  let bytes: Buffer
   try {
-    bytes = await readFile(file);
+    bytes = await readFile(file)
   } catch {
-    return undefined;
+    return undefined
   }
   // Almost every file the bundler loads has no directive at all. Search the
   // raw bytes for the only string one can be spelled with, and decode (plus
   // run the real directive-prologue test) for the few that could.
-  if (!bytes.includes('use client')) return undefined;
-  const source = bytes.toString('utf8');
-  if (!isCommonJsModuleSource(source, file) || !hasUseClientDirective(source)) return undefined;
+  if (!bytes.includes('use client')) return undefined
+  const source = bytes.toString('utf8')
+  if (!isCommonJsModuleSource(source, file) || !hasUseClientDirective(source)) return undefined
   const references = commonJsExportNames(source)
     .map(name => {
-      const value = name === 'default' ? 'exports.default' : `exports[${JSON.stringify(name)}]`;
+      const value = name === 'default' ? 'exports.default' : `exports[${JSON.stringify(name)}]`
       const reference = JSON.stringify({
         id: `c-${clientReferenceId(file, name)}`,
         file,
         exportName: name,
-      });
-      return `if (typeof ${value} === "function") ${value}[Symbol.for("pnext.clientReference")] = ${reference};`;
+      })
+      return `if (typeof ${value} === "function") ${value}[Symbol.for("pnext.clientReference")] = ${reference};`
     })
-    .join('\n');
+    .join('\n')
   return {
     contents: references ? `${source}\n${references}\n` : source,
     loader: 'js' as const,
     resolveDir: dirname(file),
-  };
-});
+  }
+})
 
 export function commonJsClientReferencePlugin(): Plugin {
   return {
     name: 'pnext-cjs-client-references',
     setup(build) {
-      build.onLoad({ filter: /\.c?js$/, namespace: 'file' }, args =>
-        clientReferenceLoad(args.path),
-      );
+      build.onLoad({ filter: /\.c?js$/, namespace: 'file' }, args => clientReferenceLoad(args.path))
     },
-  };
+  }
 }
 
 const isCommonJsJavaScriptFile = fileMemo((file: string) => {
   try {
-    return isCommonJsModuleSource(readFileSync(file, 'utf8'), file);
+    return isCommonJsModuleSource(readFileSync(file, 'utf8'), file)
   } catch {
-    return true;
+    return true
   }
-});
+})
 
 /** Entry classification is per (specifier, resolveDir) and never changes. */
-const entryResolutions = new Map<string, string | undefined>();
+const entryResolutions = new Map<string, string | undefined>()
 
 function resolveEntryPath(specifier: string, resolveDir: string) {
-  const key = `${specifier}\0${resolveDir}`;
-  if (entryResolutions.has(key)) return entryResolutions.get(key);
+  const key = `${specifier}\0${resolveDir}`
+  if (entryResolutions.has(key)) return entryResolutions.get(key)
   // The vendor build already resolved bare entry specifiers; never re-resolve.
-  const provided = providedEntryResolution(specifier, resolveDir);
+  const provided = providedEntryResolution(specifier, resolveDir)
   if (provided) {
-    entryResolutions.set(key, provided);
-    return provided;
+    entryResolutions.set(key, provided)
+    return provided
   }
-  let resolved: string | undefined;
+  let resolved: string | undefined
   try {
-    resolved = Bun.resolveSync(specifier, resolveDir);
+    resolved = Bun.resolveSync(specifier, resolveDir)
   } catch {
-    resolved = undefined;
+    resolved = undefined
   }
-  entryResolutions.set(key, resolved);
-  return resolved;
+  entryResolutions.set(key, resolved)
+  return resolved
 }
 
 // esbuild turns a bundled CommonJS dependency into an ESM wrapper whose
@@ -186,38 +184,38 @@ function resolveEntryPath(specifier: string, resolveDir: string) {
 // own `.default` value (when present) as `namespace.default`. Dynamic import
 // intentionally retains the native ESM-wrapper namespace and is left alone.
 export function rewriteStaticCommonJsNamespaceImports(source: string, file: string): string {
-  const facts = rewriteFacts(file, source);
-  const edits: { start: number; end: number; value: string }[] = [];
-  const taken: string[] = [];
+  const facts = rewriteFacts(file, source)
+  const edits: { start: number; end: number; value: string }[] = []
+  const taken: string[] = []
   for (const statement of facts.imports) {
     // Namespace-only: `import d, * as ns from 'x'` would lose its default.
-    const binding = statement.bindings[0];
-    if (statement.bindings.length !== 1 || binding?.imported !== '*') continue;
-    if (!isCommonJsImport(statement.specifier, file)) continue;
-
-    const defaultBinding = uniqueIdentifier(source, '__pnext_cjs_namespace_default', ...taken);
-    taken.push(defaultBinding);
-    const quote = source[statement.specifierStart] ?? "'";
-    const indent = statementIndent(source, statement.start);
+    const binding = statement.bindings[0]
+    if (statement.bindings.length !== 1 || binding?.imported !== '*') continue
+    if (!isCommonJsImport(statement.specifier, file)) continue
+
+    const defaultBinding = uniqueIdentifier(source, '__pnext_cjs_namespace_default', ...taken)
+    taken.push(defaultBinding)
+    const quote = source[statement.specifierStart] ?? "'"
+    const indent = statementIndent(source, statement.start)
     edits.push({
       start: statement.start,
       end: statement.end,
       value: `import ${defaultBinding} from ${quote}${statement.specifier}${quote};\n${indent}const ${binding.local} = { ...${defaultBinding} };`,
-    });
+    })
   }
-  return edits.length > 0 ? spliceSource(source, edits) : source;
+  return edits.length > 0 ? spliceSource(source, edits) : source
 }
 
 /** Leading whitespace of the line the statement starts on. */
 function statementIndent(source: string, start: number) {
-  const lineStart = source.lastIndexOf('\n', start - 1) + 1;
-  const indent = source.slice(lineStart, start);
-  return /^[\t ]*$/.test(indent) ? indent : '';
+  const lineStart = source.lastIndexOf('\n', start - 1) + 1
+  const indent = source.slice(lineStart, start)
+  return /^[\t ]*$/.test(indent) ? indent : ''
 }
 
 function isCommonJsImport(specifier: string, file: string): boolean {
-  const resolved = resolveRuntimeSpecifier(dirname(file), specifier);
-  return resolved !== undefined && extname(resolved) === '.cjs';
+  const resolved = resolveRuntimeSpecifier(dirname(file), specifier)
+  return resolved !== undefined && extname(resolved) === '.cjs'
 }
 
 export function recoverCommonJsNamedExportsPlugin(): Plugin {
@@ -225,16 +223,16 @@ export function recoverCommonJsNamedExportsPlugin(): Plugin {
     name: 'pnext-recover-cjs-named-exports',
     setup(build) {
       build.onEnd(result => {
-        const output = result.outputFiles?.[0];
-        if (!output) return;
-        const next = recoverCommonJsNamedExports(decoder.decode(output.contents));
+        const output = result.outputFiles?.[0]
+        if (!output) return
+        const next = recoverCommonJsNamedExports(decoder.decode(output.contents))
         if (next === decoder.decode(output.contents)) {
-          return;
+          return
         }
-        output.contents = encoder.encode(next);
-      });
+        output.contents = encoder.encode(next)
+      })
     },
-  };
+  }
 }
 
 // esbuild's native CommonJS dynamic-import facade only exports `default`. Webpack's namespace has the
@@ -245,7 +243,7 @@ export function recoverCommonJsNamedExportsPlugin(): Plugin {
 // The filter admits any specifier that can still land on a `.cjs` file: a bare package name, a path
 // whose final segment carries no extension, or an explicit `.cjs`. Anything ending in another extension
 // is excluded in the FILTER - esbuild's Go regexp has no lookahead, so the rule is spelled positively.
-const dynamicCjsCandidate = /^[^./]|(^|\/)[^/.]+$|\.cjs([?#]|$)/;
+const dynamicCjsCandidate = /^[^./]|(^|\/)[^/.]+$|\.cjs([?#]|$)/
 
 export function clientDynamicCommonJsImportsPlugin(root: string): Plugin {
   return {
@@ -254,9 +252,9 @@ export function clientDynamicCommonJsImportsPlugin(root: string): Plugin {
       // Per-BUILD memo of the whole classification. Each miss walks node_modules, probes package
       // targets and may parse the file for its CJS export names, overwhelmingly for the same handful
       // of lazily-imported specifiers.
-      const classified = new Map<string, { path: string; names: string[] } | undefined>();
+      const classified = new Map<string, { path: string; names: string[] } | undefined>()
       const classify = (specifier: string, resolveDir: string) => {
-        let file: string;
+        let file: string
         try {
           file =
             resolveLinkedPackageSpecifier(root, `${resolveDir}/pnext-resolve.ts`, specifier, [
@@ -264,42 +262,42 @@ export function clientDynamicCommonJsImportsPlugin(root: string): Plugin {
               'style',
               'import',
               'default',
-            ]) ?? Bun.resolveSync(specifier, resolveDir);
+            ]) ?? Bun.resolveSync(specifier, resolveDir)
         } catch {
-          return undefined;
+          return undefined
         }
-        if (extname(file) !== '.cjs') return undefined;
-        const names = commonJsExportNamesFromFile(file).filter(name => name !== 'default');
-        return names.length === 0 ? undefined : { path: file, names };
-      };
+        if (extname(file) !== '.cjs') return undefined
+        const names = commonJsExportNamesFromFile(file).filter(name => name !== 'default')
+        return names.length === 0 ? undefined : { path: file, names }
+      }
       build.onResolve({ filter: dynamicCjsCandidate }, args => {
-        if (args.kind !== 'dynamic-import' || !args.resolveDir) return undefined;
-        const key = `${args.resolveDir}\0${args.path}`;
-        let hit = classified.get(key);
+        if (args.kind !== 'dynamic-import' || !args.resolveDir) return undefined
+        const key = `${args.resolveDir}\0${args.path}`
+        let hit = classified.get(key)
         if (hit === undefined && !classified.has(key)) {
-          hit = classify(args.path, args.resolveDir);
-          classified.set(key, hit);
+          hit = classify(args.path, args.resolveDir)
+          classified.set(key, hit)
         }
-        if (!hit) return undefined;
+        if (!hit) return undefined
         return {
           path: hit.path,
           namespace: 'pnext-dynamic-cjs-facade',
           pluginData: { names: hit.names },
-        };
-      });
+        }
+      })
       build.onLoad({ filter: /.*/, namespace: 'pnext-dynamic-cjs-facade' }, args => {
-        const names = (args.pluginData as { names?: string[] } | undefined)?.names ?? [];
+        const names = (args.pluginData as { names?: string[] } | undefined)?.names ?? []
         const forwards = names
           .map(name => `export const ${name} = value[${JSON.stringify(name)}];`)
-          .join('\n');
+          .join('\n')
         return {
           contents: `import value from ${JSON.stringify(args.path)};\nexport default value;\n${forwards}\n`,
           loader: 'js',
           resolveDir: dirname(args.path),
-        };
-      });
+        }
+      })
     },
-  };
+  }
 }
 
 // React 19 renders a thenable child by unwrapping it through `use()`. Preact
@@ -315,111 +313,118 @@ export function rewriteClientDynamicImportPromises(source: string): string {
     ),
   ]
     .map(match => match[1])
-    .filter((name): name is string => Boolean(name));
-  if (names.length === 0) return source;
+    .filter((name): name is string => Boolean(name))
+  if (names.length === 0) return source
 
-  const hook = uniqueIdentifier(source, '__pnext_use');
-  let next = source;
-  let changed = false;
+  const hook = uniqueIdentifier(source, '__pnext_use')
+  let next = source
+  let changed = false
   for (const name of names) {
-    const expression = new RegExp(`\\{${escapeRegExp(name)}\\}`, 'g');
-    const rewritten = next.replace(expression, `{${hook}(${name})}`);
-    changed ||= rewritten !== next;
-    next = rewritten;
+    const expression = new RegExp(`\\{${escapeRegExp(name)}\\}`, 'g')
+    const rewritten = next.replace(expression, `{${hook}(${name})}`)
+    changed ||= rewritten !== next
+    next = rewritten
   }
-  if (!changed) return source;
+  if (!changed) return source
 
-  const directive = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(next)?.[0] ?? '';
-  return `${directive}import { use as ${hook} } from 'react';\n${next.slice(directive.length)}`;
+  const directive = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(next)?.[0] ?? ''
+  return `${directive}import { use as ${hook} } from 'react';\n${next.slice(directive.length)}`
 }
 
 function recoverCommonJsNamedExports(code: string) {
-  if (hasNonDefaultExport(code)) return code;
+  if (hasNonDefaultExport(code)) return code
   const names = [...new Set([...commonJsExportNames(code), ...esbuildEntryExportNames(code)])]
     .filter(name => name !== 'default' && name !== '__esModule')
-    .sort();
-  if (names.length === 0) return code;
-
-  const directDefaultExport = /(^|\n)export default ([^;\n]+);/.exec(code);
-  const listedDefaultExport = /(^|\n)export\s*\{\s*([A-Za-z_$][\w$]*)\s+as\s+default\s*,?\s*\};?/.exec(
-    code,
-  );
-  const defaultExport = directDefaultExport ?? listedDefaultExport;
-  if (!defaultExport?.[2]) return code;
-
-  const defaultName = uniqueIdentifier(code, '__pnext_cjs_default');
-  const namespaceName = commonJsNamespaceBinding(code, defaultExport[2]);
-  const usedNames = [defaultName];
+    .sort()
+  if (names.length === 0) return code
+
+  const directDefaultExport = /(^|\n)export default ([^;\n]+);/.exec(code)
+  const listedDefaultExport =
+    /(^|\n)export\s*\{\s*([A-Za-z_$][\w$]*)\s+as\s+default\s*,?\s*\};?/.exec(code)
+  const defaultExport = directDefaultExport ?? listedDefaultExport
+  if (!defaultExport?.[2]) return code
+
+  const defaultName = uniqueIdentifier(code, '__pnext_cjs_default')
+  const namespaceName = commonJsNamespaceBinding(code, defaultExport[2])
+  const usedNames = [defaultName]
   const bindings = names.map(name => {
-    const localName = uniqueIdentifier(code, `__pnext_cjs_export_${name}`, ...usedNames);
-    usedNames.push(localName);
-    return { name, localName };
-  });
+    const localName = uniqueIdentifier(code, `__pnext_cjs_export_${name}`, ...usedNames)
+    usedNames.push(localName)
+    return { name, localName }
+  })
   const namedBindings = bindings
     .map(
       ({ name, localName }) =>
-        `const ${localName} = ${(namespaceName ?? defaultName)}[${JSON.stringify(name)}];`,
+        `const ${localName} = ${namespaceName ?? defaultName}[${JSON.stringify(name)}];`,
     )
-    .join('\n');
-  const namedExports = bindings.map(({ name, localName }) => `${localName} as ${name}`).join(', ');
+    .join('\n')
+  const namedExports = bindings.map(({ name, localName }) => `${localName} as ${name}`).join(', ')
 
   return code.replace(
     defaultExport[0],
     `${defaultExport[1]}const ${defaultName} = ${defaultExport[2]};\nexport default ${defaultName};\n${namedBindings}\nexport { ${namedExports} };\n`,
-  );
+  )
 }
 
 function commonJsNamespaceBinding(code: string, defaultName: string) {
   const assignment = new RegExp(
     `(?:^|\\n)(?:var|const|let)\\s+${escapeRegExp(defaultName)}\\s*=\\s*([A-Za-z_$][\\w$]*)\\.default\\s*;`,
-  ).exec(code);
-  if (assignment?.[1]) return assignment[1];
+  ).exec(code)
+  if (assignment?.[1]) return assignment[1]
 
   return new RegExp(
     `(?:^|\\n)(?:var|const|let)\\s+${escapeRegExp(defaultName)}\\s*=\\s*([A-Za-z_$][\\w$]*)\\s*!=\\s*null\\s*&&[\\s\\S]*?\\?\\s*\\1\\.default\\s*:\\s*\\1\\s*;`,
-  ).exec(code)?.[1];
+  ).exec(code)?.[1]
 }
 
 function hasNonDefaultExport(code: string) {
-  if (/(^|\n)export\s+(?:\*|(?:const|let|var|function|class)\s+)/.test(code)) return true;
+  if (/(^|\n)export\s+(?:\*|(?:const|let|var|function|class)\s+)/.test(code)) return true
   for (const statement of code.matchAll(/(^|\n)export\s*\{([^}]*)\}/g)) {
     const names = (statement[2] ?? '')
       .split(',')
-      .map(name => name.trim().split(/\s+as\s+/i).at(-1))
-      .filter((name): name is string => Boolean(name));
-    if (names.some(name => name !== 'default')) return true;
+      .map(name =>
+        name
+          .trim()
+          .split(/\s+as\s+/i)
+          .at(-1),
+      )
+      .filter((name): name is string => Boolean(name))
+    if (names.some(name => name !== 'default')) return true
   }
-  return false;
+  return false
 }
 
 function commonJsExportNames(code: string) {
   return [
-    ...new Set([
-      ...[...code.matchAll(/\bexports\.([A-Za-z_$][\w$]*)\s*=\s*/g)].map(match => match[1]),
-      ...[
-        ...code.matchAll(
-          /\bObject\.defineProperty\(\s*exports\s*,\s*["']([A-Za-z_$][\w$]*)["']/g,
-        ),
-      ].map(match => match[1]),
-      ...extractModuleExportsObjectNames(code),
-    ]
-      .filter((name): name is string => Boolean(name && name !== '__esModule' && isIdentifier(name)))
-      .sort(),
+    ...new Set(
+      [
+        ...[...code.matchAll(/\bexports\.([A-Za-z_$][\w$]*)\s*=\s*/g)].map(match => match[1]),
+        ...[
+          ...code.matchAll(
+            /\bObject\.defineProperty\(\s*exports\s*,\s*["']([A-Za-z_$][\w$]*)["']/g,
+          ),
+        ].map(match => match[1]),
+        ...extractModuleExportsObjectNames(code),
+      ]
+        .filter((name): name is string =>
+          Boolean(name && name !== '__esModule' && isIdentifier(name)),
+        )
+        .sort(),
     ),
-  ];
+  ]
 }
 
 function commonJsExportNamesFromFile(file: string, visited = new Set<string>()): string[] {
-  if (visited.has(file)) return [];
-  visited.add(file);
-  let code: string;
+  if (visited.has(file)) return []
+  visited.add(file)
+  let code: string
   try {
-    code = readFileSync(file, 'utf8');
+    code = readFileSync(file, 'utf8')
   } catch {
-    return [];
+    return []
   }
-  const names = commonJsExportNames(code);
-  if (names.length > 0) return names;
+  const names = commonJsExportNames(code)
+  if (names.length > 0) return names
 
   // Follow the simple `const value = require('...'); module.exports = value`
   // form used by packages that re-export an `imports` map entry, plus the
@@ -427,116 +432,159 @@ function commonJsExportNamesFromFile(file: string, visited = new Set<string>()):
   const reexport =
     /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)[\s\S]*?\bmodule\.exports\s*=\s*\1\s*;?/.exec(
       code,
-    ) ?? /\bmodule\.exports\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)/.exec(code);
-  const specifier = reexport?.[2] ?? reexport?.[1];
-  if (!specifier) return [];
+    ) ?? /\bmodule\.exports\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)/.exec(code)
+  const specifier = reexport?.[2] ?? reexport?.[1]
+  if (!specifier) return []
   try {
-    return commonJsExportNamesFromFile(Bun.resolveSync(specifier, dirname(file)), visited);
+    return commonJsExportNamesFromFile(Bun.resolveSync(specifier, dirname(file)), visited)
   } catch {
-    return [];
+    return []
   }
 }
 
 function escapeRegExp(value: string) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
 function extractModuleExportsObjectNames(code: string) {
-  const start = /\bmodule\.exports\s*=\s*\{/.exec(code);
-  if (!start) return [];
-  const objectBody = topLevelObjectBody(code, start.index + start[0].length - 1);
-  if (objectBody === undefined) return [];
-  return [...objectBody.matchAll(/(?:^|,)\s*(?:([A-Za-z_$][\w$]*)\s*:|["']([A-Za-z_$][\w$]*)["']\s*:)/g)]
+  const start = /\bmodule\.exports\s*=\s*\{/.exec(code)
+  if (!start) return []
+  const objectBody = topLevelObjectBody(code, start.index + start[0].length - 1)
+  if (objectBody === undefined) return []
+  return [
+    ...objectBody.matchAll(/(?:^|,)\s*(?:([A-Za-z_$][\w$]*)\s*:|["']([A-Za-z_$][\w$]*)["']\s*:)/g),
+  ]
     .map(match => match[1] || match[2])
-    .filter((name): name is string => Boolean(name && isIdentifier(name)));
+    .filter((name): name is string => Boolean(name && isIdentifier(name)))
 }
 
 // Scan an object literal from its opening brace, keeping only top-level text: nested bodies, strings
 // and comments are blanked out so a nested key (or a comment separating keys) cannot be mistaken for -
 // or hide - a top-level one. Returns undefined when the literal is unterminated.
 function topLevelObjectBody(code: string, openIndex: number): string | undefined {
-  let depth = 0;
-  let out = '';
+  let depth = 0
+  let out = ''
   for (let index = openIndex; index < code.length; index += 1) {
-    const char = code[index]!;
+    const char = code[index]!
     if (char === '"' || char === "'" || char === '`') {
-      const end = skipString(code, index, char);
-      if (depth === 1) out += ' '.repeat(end - index + 1);
-      index = end;
-      continue;
+      const end = skipString(code, index, char)
+      if (depth === 1) out += ' '.repeat(end - index + 1)
+      index = end
+      continue
     }
     if (char === '/' && (code[index + 1] === '/' || code[index + 1] === '*')) {
-      const end = commentEnd(code, index);
-      if (depth === 1) out += ' '.repeat(end - index + 1);
-      index = end;
-      continue;
+      const end = commentEnd(code, index)
+      if (depth === 1) out += ' '.repeat(end - index + 1)
+      index = end
+      continue
     }
     if (char === '{' || char === '[' || char === '(') {
-      depth += 1;
-      if (depth === 1) continue;
-      out += depth === 2 ? ' ' : '';
-      continue;
+      depth += 1
+      if (depth === 1) continue
+      out += depth === 2 ? ' ' : ''
+      continue
     }
     if (char === '}' || char === ']' || char === ')') {
-      depth -= 1;
-      if (depth === 0) return out;
-      continue;
+      depth -= 1
+      if (depth === 0) return out
+      continue
     }
-    if (depth === 1) out += char;
+    if (depth === 1) out += char
   }
-  return undefined;
+  return undefined
 }
 
 // Index of the last character of the comment starting at `start`.
 function commentEnd(code: string, start: number): number {
   if (code[start + 1] === '/') {
-    const newline = code.indexOf('\n', start);
-    return (newline < 0 ? code.length : newline) - 1;
+    const newline = code.indexOf('\n', start)
+    return (newline < 0 ? code.length : newline) - 1
   }
-  const close = code.indexOf('*/', start);
-  return close < 0 ? code.length - 1 : close + 1;
+  const close = code.indexOf('*/', start)
+  return close < 0 ? code.length - 1 : close + 1
 }
 
 function skipString(code: string, start: number, quote: string): number {
   for (let index = start + 1; index < code.length; index += 1) {
-    const char = code[index];
+    const char = code[index]
     if (char === '\\') {
-      index += 1;
-      continue;
+      index += 1
+      continue
     }
-    if (char === quote) return index;
+    if (char === quote) return index
   }
-  return code.length - 1;
+  return code.length - 1
 }
 
 // Reserved words are legal CommonJS object keys but illegal export bindings, so
 // a `module.exports = { class: … }` entry must not reach the facade.
 const reservedWords = new Set([
-  'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default',
-  'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function',
-  'if', 'implements', 'import', 'in', 'instanceof', 'interface', 'let', 'new', 'null',
-  'package', 'private', 'protected', 'public', 'return', 'static', 'super', 'switch', 'this',
-  'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield',
-]);
+  'await',
+  'break',
+  'case',
+  'catch',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'else',
+  'enum',
+  'export',
+  'extends',
+  'false',
+  'finally',
+  'for',
+  'function',
+  'if',
+  'implements',
+  'import',
+  'in',
+  'instanceof',
+  'interface',
+  'let',
+  'new',
+  'null',
+  'package',
+  'private',
+  'protected',
+  'public',
+  'return',
+  'static',
+  'super',
+  'switch',
+  'this',
+  'throw',
+  'true',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'while',
+  'with',
+  'yield',
+])
 
 export const namedFacadeExportNames = fileMemo((file: string): string[] =>
   commonJsExportNamesFromFile(file).filter(
     name => name !== 'default' && name !== '__esModule' && !reservedWords.has(name),
   ),
-);
+)
 
 // Recover named exports from esbuild's `__export(entry, {...}); module.exports = __toCommonJS(entry)` shape.
 function esbuildEntryExportNames(code: string) {
   const toCommonJs = [
     ...code.matchAll(/module\.exports\s*=\s*__toCommonJS\w*\(\s*([A-Za-z_$][\w$]*)\s*\)/g),
-  ];
-  const entryVar = toCommonJs.at(-1)?.[1];
-  if (!entryVar) return [];
+  ]
+  const entryVar = toCommonJs.at(-1)?.[1]
+  if (!entryVar) return []
   const exportCall = new RegExp(
     `__export\\w*\\(\\s*${entryVar}\\s*,\\s*\\{([\\s\\S]*?)\\}\\s*\\)`,
-  ).exec(code);
-  if (!exportCall?.[1]) return [];
+  ).exec(code)
+  if (!exportCall?.[1]) return []
   return [...exportCall[1].matchAll(/(?:^|,)\s*([A-Za-z_$][\w$]*)\s*:/g)]
     .map(match => match[1])
-    .filter((name): name is string => Boolean(name && isIdentifier(name)));
+    .filter((name): name is string => Boolean(name && isIdentifier(name)))
 }