@wular/pnext 0.0.3 → 0.0.6

package/src/compat/lifecycle/testmode.ts

@@ -6,25 +6,25 @@
 // exactly once at init and consults it - a no-op when no proxy info is active. Gated on
 // experimental.testProxy in next.config.
 
-import { PassThrough } from 'node:stream';
-import type * as http from 'node:http';
-import type * as https from 'node:https';
-import type { IncomingMessage } from 'node:http';
-import { createRequire } from 'node:module';
-import { currentRequest, getWorkUnit } from '../../request/context';
+import { PassThrough } from 'node:stream'
+import type * as http from 'node:http'
+import type * as https from 'node:https'
+import type { IncomingMessage } from 'node:http'
+import { createRequire } from 'node:module'
+import { currentRequest, getWorkUnit } from '../../request/context'
 
 // `import * as http` yields a frozen ES module namespace object under strict
 // runtimes (Bun); assigning to `.get` on it throws "Attempted to assign to
 // readonly property." `require()` returns the real, mutable CJS exports
 // object that node/http/https resolve `.get` calls through at runtime, so
 // patch that instead of the namespace binding.
-const requireNode = createRequire(import.meta.url);
-const httpModule = requireNode('node:http') as typeof http;
-const httpsModule = requireNode('node:https') as typeof https;
+const requireNode = createRequire(import.meta.url)
+const httpModule = requireNode('node:http') as typeof http
+const httpsModule = requireNode('node:https') as typeof https
 
 interface TestProxyInfo {
-  proxyPort: number;
-  testData: string;
+  proxyPort: number
+  testData: string
 }
 
 /**
@@ -32,54 +32,54 @@ interface TestProxyInfo {
  * private ALS, so the patched global.fetch - invoked deep inside a render or handler - can recover it
  * via getWorkUnit(). The interceptor sets it before matching; the fetch patch reads it.
  */
-const TEST_PROXY_KEY = Symbol.for('pnext.testProxy');
+const TEST_PROXY_KEY = Symbol.for('pnext.testProxy')
 
 /** Extract proxy info from a request's Next-Test-* headers, if present. */
 export function readTestProxyInfo(headers: Headers): TestProxyInfo | undefined {
-  const portHeader = headers.get('next-test-proxy-port');
-  if (!portHeader) return undefined;
-  return { proxyPort: Number(portHeader), testData: headers.get('next-test-data') ?? '' };
+  const portHeader = headers.get('next-test-proxy-port')
+  if (!portHeader) return undefined
+  return { proxyPort: Number(portHeader), testData: headers.get('next-test-data') ?? '' }
 }
 
 /** Record the request's test-proxy info onto the active work unit (if any). */
 export function activateTestProxy(headers: Headers): void {
-  const info = readTestProxyInfo(headers);
-  if (!info) return;
-  const unit = getWorkUnit();
-  if (!unit) return;
-  (unit.compat ??= {})[TEST_PROXY_KEY] = info;
+  const info = readTestProxyInfo(headers)
+  if (!info) return
+  const unit = getWorkUnit()
+  if (!unit) return
+  ;(unit.compat ??= {})[TEST_PROXY_KEY] = info
 }
 
 function currentTestProxyInfo(): TestProxyInfo | undefined {
-  const workUnitInfo = getWorkUnit()?.compat?.[TEST_PROXY_KEY] as TestProxyInfo | undefined;
-  if (workUnitInfo) return workUnitInfo;
-  const request = currentRequest();
-  if (!request) return undefined;
-  return readTestProxyInfo(request.headers);
+  const workUnitInfo = getWorkUnit()?.compat?.[TEST_PROXY_KEY] as TestProxyInfo | undefined
+  if (workUnitInfo) return workUnitInfo
+  const request = currentRequest()
+  if (!request) return undefined
+  return readTestProxyInfo(request.headers)
 }
 
 // pnext marks its own proxy round-trips via `next.internal` so the patched
 // fetch (below) doesn't re-intercept them. The `next` field is typed as
 // NextFetchRequestConfig globally, so extend it via intersection rather than
 // interface-extends (which errors on the conflicting `next` property).
-type InternalInit = RequestInit & { next?: { internal?: boolean } };
+type InternalInit = RequestInit & { next?: { internal?: boolean } }
 
 interface ProxyFetchRequest {
-  testData: string;
-  api: 'fetch';
+  testData: string
+  api: 'fetch'
   request: {
-    url: string;
-    method: string;
-    headers: [string, string][];
-    body: string | null;
-    cache: RequestCache;
-    credentials: RequestCredentials;
-    integrity: string;
-    mode: RequestMode;
-    redirect: RequestRedirect;
-    referrer: string;
-    referrerPolicy: ReferrerPolicy;
-  };
+    url: string
+    method: string
+    headers: [string, string][]
+    body: string | null
+    cache: RequestCache
+    credentials: RequestCredentials
+    integrity: string
+    mode: RequestMode
+    redirect: RequestRedirect
+    referrer: string
+    referrerPolicy: ReferrerPolicy
+  }
 }
 
 async function buildProxyRequest(testData: string, request: Request): Promise<ProxyFetchRequest> {
@@ -89,10 +89,7 @@ async function buildProxyRequest(testData: string, request: Request): Promise<Pr
     request: {
       url: request.url,
       method: request.method,
-      headers: [
-        ...Array.from(request.headers),
-        ['next-test-stack', getTestStack()],
-      ],
+      headers: [...Array.from(request.headers), ['next-test-stack', getTestStack()]],
       body: request.body ? Buffer.from(await request.arrayBuffer()).toString('base64') : null,
       cache: request.cache,
       credentials: request.credentials,
@@ -107,27 +104,27 @@ async function buildProxyRequest(testData: string, request: Request): Promise<Pr
       referrer: request.referrer,
       referrerPolicy: request.referrerPolicy,
     },
-  };
+  }
 }
 
 function getTestStack(): string {
-  let stack = (new Error().stack ?? '').split('\n');
+  let stack = (new Error().stack ?? '').split('\n')
   for (let i = 1; i < stack.length; i++) {
-    const line = stack[i];
+    const line = stack[i]
     if (line && line.length > 0) {
-      stack = stack.slice(i);
-      break;
+      stack = stack.slice(i)
+      break
     }
   }
-  stack = stack.filter(item => !item.includes('/next/dist/'));
-  stack = stack.slice(0, 5);
-  stack = stack.map(line => line.replace('webpack-internal:///(rsc)/', '').trim());
-  return stack.join('    ');
+  stack = stack.filter(item => !item.includes('/next/dist/'))
+  stack = stack.slice(0, 5)
+  stack = stack.map(line => line.replace('webpack-internal:///(rsc)/', '').trim())
+  return stack.join('    ')
 }
 
 interface ProxyResponse {
-  api: 'continue' | 'abort' | 'unhandled' | 'fetch';
-  response?: { status: number; headers: [string, string][]; body: string | null };
+  api: 'continue' | 'abort' | 'unhandled' | 'fetch'
+  response?: { status: number; headers: [string, string][]; body: string | null }
 }
 
 async function handleProxiedFetch(
@@ -135,129 +132,160 @@ async function handleProxiedFetch(
   info: TestProxyInfo,
   request: Request,
 ): Promise<Response> {
-  const proxyRequest = await buildProxyRequest(info.testData, request);
+  const proxyRequest = await buildProxyRequest(info.testData, request)
   const resp = await originalFetch(`http://localhost:${info.proxyPort}`, {
     method: 'POST',
     body: JSON.stringify(proxyRequest),
     next: { internal: true },
-  } as InternalInit);
-  if (!resp.ok) throw new Error(`Proxy request failed: ${resp.status}`);
-  const proxyResponse = (await resp.json()) as ProxyResponse;
+  } as InternalInit)
+  if (!resp.ok) throw new Error(`Proxy request failed: ${resp.status}`)
+  const proxyResponse = (await resp.json()) as ProxyResponse
   switch (proxyResponse.api) {
     case 'continue':
-      return originalFetch(request);
+      return originalFetch(request)
     case 'fetch': {
-      const r = proxyResponse.response!;
+      const r = proxyResponse.response!
       return new Response(r.body ? Buffer.from(r.body, 'base64') : null, {
         status: r.status,
         headers: new Headers(r.headers),
-      });
+      })
     }
     default:
-      throw new Error(`Proxy request aborted [${request.method} ${request.url}]`);
+      throw new Error(`Proxy request aborted [${request.method} ${request.url}]`)
   }
 }
 
-type TestGetCallback = (res: IncomingMessage) => void;
-type HttpGetInput = Parameters<typeof http.get>[0];
+type TestGetCallback = (res: IncomingMessage) => void
+type HttpGetInput = Parameters<typeof http.get>[0]
 
-function buildResponseMessage(responsePromise: Promise<Response>, callback?: TestGetCallback): IncomingMessage {
-  const stream = new PassThrough();
-  const message = stream as unknown as IncomingMessage;
-  void responsePromise.then(async response => {
-    const headers: Record<string, string> = {};
-    const rawHeaders: string[] = [];
-    for (const [name, value] of response.headers) {
-      headers[name.toLowerCase()] = value;
-      rawHeaders.push(name, value);
-    }
-    message.statusCode = response.status;
-    message.statusMessage = response.statusText;
-    message.headers = headers;
-    message.rawHeaders = rawHeaders;
-    message.complete = true;
-    callback?.(message);
-    const body = await response.arrayBuffer();
-    stream.end(Buffer.from(body));
-  }).catch(error => {
-    stream.emit('error', error);
-    stream.end();
-  });
-  return message;
+function buildResponseMessage(
+  responsePromise: Promise<Response>,
+  callback?: TestGetCallback,
+): IncomingMessage {
+  const stream = new PassThrough()
+  const message = stream as unknown as IncomingMessage
+  void responsePromise
+    .then(async response => {
+      const headers: Record<string, string> = {}
+      const rawHeaders: string[] = []
+      for (const [name, value] of response.headers) {
+        headers[name.toLowerCase()] = value
+        rawHeaders.push(name, value)
+      }
+      message.statusCode = response.status
+      message.statusMessage = response.statusText
+      message.headers = headers
+      message.rawHeaders = rawHeaders
+      message.complete = true
+      callback?.(message)
+      const body = await response.arrayBuffer()
+      stream.end(Buffer.from(body))
+    })
+    .catch(error => {
+      stream.emit('error', error)
+      stream.end()
+    })
+  return message
 }
 
 function getStringForGetInput(input: HttpGetInput): string | undefined {
-  if (typeof input === 'string' || input instanceof URL) return input.toString();
-  const candidate = input as { href?: string; protocol?: string; hostname?: string; host?: string; path?: string; pathname?: string; search?: string; port?: number | string };
-  if (typeof candidate.href === 'string' && /^[a-z][a-z\d+.-]*:\/\//i.test(candidate.href)) return candidate.href;
-  const protocol = typeof candidate.protocol === 'string' ? candidate.protocol : 'http:';
-  const host = typeof candidate.host === 'string' ? candidate.host : typeof candidate.hostname === 'string' ? candidate.hostname : undefined;
-  if (!host) return undefined;
+  if (typeof input === 'string' || input instanceof URL) return input.toString()
+  const candidate = input as {
+    href?: string
+    protocol?: string
+    hostname?: string
+    host?: string
+    path?: string
+    pathname?: string
+    search?: string
+    port?: number | string
+  }
+  if (typeof candidate.href === 'string' && /^[a-z][a-z\d+.-]*:\/\//i.test(candidate.href))
+    return candidate.href
+  const protocol = typeof candidate.protocol === 'string' ? candidate.protocol : 'http:'
+  const host =
+    typeof candidate.host === 'string'
+      ? candidate.host
+      : typeof candidate.hostname === 'string'
+        ? candidate.hostname
+        : undefined
+  if (!host) return undefined
   const port =
-    typeof candidate.port === 'number' ? `:${candidate.port}` : typeof candidate.port === 'string' ? `:${candidate.port}` : '';
-  const path = typeof candidate.path === 'string' ? candidate.path : typeof candidate.pathname === 'string' ? candidate.pathname : '/';
-  const search = typeof candidate.search === 'string' ? candidate.search : '';
-  return `${protocol}//${host}${port}${path}${search}`;
+    typeof candidate.port === 'number'
+      ? `:${candidate.port}`
+      : typeof candidate.port === 'string'
+        ? `:${candidate.port}`
+        : ''
+  const path =
+    typeof candidate.path === 'string'
+      ? candidate.path
+      : typeof candidate.pathname === 'string'
+        ? candidate.pathname
+        : '/'
+  const search = typeof candidate.search === 'string' ? candidate.search : ''
+  return `${protocol}//${host}${port}${path}${search}`
 }
 
-function patchableGet(
-  originalGet: typeof http.get,
-  originalFetch: typeof fetch,
-): typeof http.get {
+function patchableGet(originalGet: typeof http.get, originalFetch: typeof fetch): typeof http.get {
   return ((input: HttpGetInput, options?: Parameters<typeof http.get>[1]) => {
-    const callback = typeof options === 'function' ? options : undefined;
-    const url = getStringForGetInput(input);
-    const info = currentTestProxyInfo();
+    const callback = typeof options === 'function' ? options : undefined
+    const url = getStringForGetInput(input)
+    const info = currentTestProxyInfo()
     if (!url || !info) {
       if (typeof options === 'function') {
-        return originalGet(input, options);
+        return originalGet(input, options)
       }
       if (options === undefined) {
-        return originalGet(input);
+        return originalGet(input)
       }
-      return originalGet(input, options);
+      return originalGet(input, options)
     }
     const request = new Request(url, {
-      method: typeof options === 'object' && options && 'method' in options && typeof options.method === 'string'
-        ? options.method
-        : 'GET',
+      method:
+        typeof options === 'object' &&
+        options &&
+        'method' in options &&
+        typeof options.method === 'string'
+          ? options.method
+          : 'GET',
       headers:
         typeof options === 'object' && options && 'headers' in options
           ? (options.headers as HeadersInit)
           : undefined,
-    });
-    return buildResponseMessage(handleProxiedFetch(originalFetch, info, request), callback) as unknown as ReturnType<
-      typeof http.get
-    >;
-  }) as typeof http.get;
+    })
+    return buildResponseMessage(
+      handleProxiedFetch(originalFetch, info, request),
+      callback,
+    ) as unknown as ReturnType<typeof http.get>
+  }) as typeof http.get
 }
 
-let patched = false;
+let patched = false
 
 /** Patch global.fetch and node http/https.get once for testmode outgoing requests. */
 export function installTestProxyFetch(): void {
-  if (patched) return;
-  patched = true;
-  const originalFetch = globalThis.fetch.bind(globalThis);
+  if (patched) return
+  patched = true
+  const originalFetch = globalThis.fetch.bind(globalThis)
 
   const testFetch = function testFetch(
     input: Parameters<typeof fetch>[0],
     init?: Parameters<typeof fetch>[1],
   ): Promise<Response> {
-    const nextInit = (init as { next?: { internal?: boolean } } | undefined)?.next;
+    const nextInit = (init as { next?: { internal?: boolean } } | undefined)?.next
     if (nextInit?.internal) {
-      return originalFetch(input, init);
+      return originalFetch(input, init)
     }
-    const info = currentTestProxyInfo();
-    if (!info) return originalFetch(input, init);
-    return handleProxiedFetch(originalFetch, info, new Request(input, init));
-  };
+    const info = currentTestProxyInfo()
+    if (!info) return originalFetch(input, init)
+    return handleProxiedFetch(originalFetch, info, new Request(input, init))
+  }
   // Preserve fetch.preconnect (typeof fetch requires it).
-  (testFetch as typeof fetch).preconnect = originalFetch.preconnect?.bind(originalFetch);
-  globalThis.fetch = testFetch as typeof fetch;
+  ;(testFetch as typeof fetch).preconnect = originalFetch.preconnect?.bind(originalFetch)
+  globalThis.fetch = testFetch as typeof fetch
 
-  const originalHttpGet = httpModule.get;
-  const originalHttpsGet = httpsModule.get;
-  httpModule.get = patchableGet(originalHttpGet, originalFetch);
-  httpsModule.get = patchableGet(originalHttpsGet, originalFetch);
+  const originalHttpGet = httpModule.get
+  const originalHttpsGet = httpsModule.get
+  httpModule.get = patchableGet(originalHttpGet, originalFetch)
+  httpsModule.get = patchableGet(originalHttpsGet, originalFetch)
 }

package/src/compat/mdx/compile.ts

@@ -14,32 +14,32 @@
 // `providerImportSource` is set to our components provider only when the app ships an `mdx-components`
 // file; without one, MDX emits bare host elements, which is exactly the mdx-no-mdx-components contract.
 
-import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { getNextConfig } from '../next/config-loader';
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { getNextConfig } from '../next/config-loader'
 
 export interface MdxCompileResult {
-  code: string;
+  code: string
 }
 
 interface MdxModule {
   compile: (
     source: string | { value: string; path?: string },
     options?: Record<string, unknown>,
-  ) => Promise<{ toString: () => string; value: string }>;
+  ) => Promise<{ toString: () => string; value: string }>
 }
 
 interface MdxOptions {
-  remarkPlugins?: unknown[];
-  rehypePlugins?: unknown[];
-  recmaPlugins?: unknown[];
-  remarkRehypeOptions?: Record<string, unknown>;
-  providerImportSource?: string;
+  remarkPlugins?: unknown[]
+  rehypePlugins?: unknown[]
+  recmaPlugins?: unknown[]
+  remarkRehypeOptions?: Record<string, unknown>
+  providerImportSource?: string
 }
 
-let cachedModule: MdxModule | null | undefined;
+let cachedModule: MdxModule | null | undefined
 
 /**
  * Load `@mdx-js/mdx` lazily. Returns `null` (not throwing) when the optional
@@ -47,26 +47,26 @@ let cachedModule: MdxModule | null | undefined;
  * when an app actually imports `.mdx`.
  */
 async function loadMdx(): Promise<MdxModule | null> {
-  if (cachedModule !== undefined) return cachedModule;
+  if (cachedModule !== undefined) return cachedModule
   try {
-    const specifier = '@mdx-js/mdx';
-    cachedModule = (await import(/* @vite-ignore */ specifier)) as MdxModule;
+    const specifier = '@mdx-js/mdx'
+    cachedModule = (await import(/* @vite-ignore */ specifier)) as MdxModule
   } catch {
-    cachedModule = null;
+    cachedModule = null
   }
-  return cachedModule;
+  return cachedModule
 }
 
 /** The user's mdxOptions from the wrapped next.config, normalized. */
 export function mdxOptionsFromConfig(): MdxOptions {
   const config = getNextConfig() as {
-    mdxOptions?: MdxOptions;
-    experimental?: { mdxRs?: unknown };
-  };
+    mdxOptions?: MdxOptions
+    experimental?: { mdxRs?: unknown }
+  }
   // @next/mdx stores the merged plugin options under `mdxOptions` on the config
   // object the wrapper produces. `experimental.mdxRs` selects the Rust pipeline
   // upstream; we always use the JS pipeline, so it is intentionally ignored.
-  return config.mdxOptions ?? {};
+  return config.mdxOptions ?? {}
 }
 
 /**
@@ -75,24 +75,30 @@ export function mdxOptionsFromConfig(): MdxOptions {
  * used as `providerImportSource`, or `undefined` when absent (bare host elements).
  */
 export function resolveMdxComponents(root: string): string | undefined {
-  const bases = [root, path.join(root, 'src')];
-  const names = ['mdx-components.tsx', 'mdx-components.ts', 'mdx-components.jsx', 'mdx-components.js', 'mdx-components.mjs'];
+  const bases = [root, path.join(root, 'src')]
+  const names = [
+    'mdx-components.tsx',
+    'mdx-components.ts',
+    'mdx-components.jsx',
+    'mdx-components.js',
+    'mdx-components.mjs',
+  ]
   for (const base of bases) {
     for (const name of names) {
-      const candidate = path.join(base, name);
-      if (existsSync(candidate)) return candidate;
+      const candidate = path.join(base, name)
+      if (existsSync(candidate)) return candidate
     }
   }
-  return undefined;
+  return undefined
 }
 
 function interopDefault(module: unknown): unknown {
-  return (module as { default?: unknown })?.default ?? module;
+  return (module as { default?: unknown })?.default ?? module
 }
 
 // Sentinel returned when a configured plugin package can't be resolved from the
 // app, so `resolvePlugins` can filter it out.
-const UNRESOLVED_PLUGIN = Symbol('pnext.mdx.unresolved-plugin');
+const UNRESOLVED_PLUGIN = Symbol('pnext.mdx.unresolved-plugin')
 
 /**
  * Resolve a single plugin entry to the shape `@mdx-js/mdx` expects. `@next/mdx` stores plugins as
@@ -107,21 +113,18 @@ const UNRESOLVED_PLUGIN = Symbol('pnext.mdx.unresolved-plugin');
  * all. Load failures are common when the toolchain resolves into a flat auto-install cache rather than
  * a real node_modules tree, so the real error is surfaced to the log instead of silently 500ing pages.
  */
-async function resolvePlugin(
-  entry: unknown,
-  resolveFrom: NodeRequire,
-): Promise<unknown> {
-  if (typeof entry === 'function') return entry;
+async function resolvePlugin(entry: unknown, resolveFrom: NodeRequire): Promise<unknown> {
+  if (typeof entry === 'function') return entry
   if (typeof entry === 'string') {
-    return loadPlugin(entry, resolveFrom);
+    return loadPlugin(entry, resolveFrom)
   }
   if (Array.isArray(entry) && typeof entry[0] === 'string') {
-    const tuple = entry as unknown[];
-    const plugin = await loadPlugin(tuple[0] as string, resolveFrom);
-    if (plugin === UNRESOLVED_PLUGIN) return UNRESOLVED_PLUGIN;
-    return [plugin, ...tuple.slice(1)];
+    const tuple = entry as unknown[]
+    const plugin = await loadPlugin(tuple[0] as string, resolveFrom)
+    if (plugin === UNRESOLVED_PLUGIN) return UNRESOLVED_PLUGIN
+    return [plugin, ...tuple.slice(1)]
   }
-  return entry;
+  return entry
 }
 
 /**
@@ -131,32 +134,32 @@ async function resolvePlugin(
  * so the toolchain stays inside the app's node_modules.
  */
 async function loadPlugin(name: string, resolveFrom: NodeRequire): Promise<unknown> {
-  let resolved: string;
+  let resolved: string
   try {
-    resolved = resolveFrom.resolve(name);
+    resolved = resolveFrom.resolve(name)
   } catch {
     console.warn(
       `pnext: MDX plugin '${name}' is configured but not installed; skipping it. ` +
         'Install it to apply this remark/rehype/recma plugin.',
-    );
-    return UNRESOLVED_PLUGIN;
+    )
+    return UNRESOLVED_PLUGIN
   }
   try {
-    return interopDefault(await import(pathToFileURL(resolved).href));
+    return interopDefault(await import(pathToFileURL(resolved).href))
   } catch (error) {
     console.warn(
       `pnext: MDX plugin '${name}' failed to load and was skipped: ` +
         `${error instanceof Error ? error.message : String(error)}. ` +
         'Ensure it is installed in the app’s node_modules (not only Bun’s auto-install cache).',
-    );
-    return UNRESOLVED_PLUGIN;
+    )
+    return UNRESOLVED_PLUGIN
   }
 }
 
 /** Resolve every entry of a remark/rehype/recma plugin array (skipping absent packages). */
 async function resolvePlugins(plugins: unknown[], resolveFrom: NodeRequire): Promise<unknown[]> {
-  const resolved = await Promise.all(plugins.map(entry => resolvePlugin(entry, resolveFrom)));
-  return resolved.filter(entry => entry !== UNRESOLVED_PLUGIN);
+  const resolved = await Promise.all(plugins.map(entry => resolvePlugin(entry, resolveFrom)))
+  return resolved.filter(entry => entry !== UNRESOLVED_PLUGIN)
 }
 
 /**
@@ -168,25 +171,25 @@ export async function compileMdx(
   filePath: string,
   root: string,
 ): Promise<MdxCompileResult> {
-  const mdx = await loadMdx();
+  const mdx = await loadMdx()
   if (!mdx) {
     throw new Error(
       "MDX support requires the '@mdx-js/mdx' package. Install it to render .mdx files.",
-    );
+    )
   }
 
-  const userOptions = mdxOptionsFromConfig();
-  const provider = resolveMdxComponents(root);
+  const userOptions = mdxOptionsFromConfig()
+  const provider = resolveMdxComponents(root)
 
   // Resolve string/tuple plugin names (@next/mdx's serialized form) to actual
   // plugin functions from the app's node_modules before handing them to MDX.
-  const resolveFrom = createRequire(path.join(root, 'noop.js'));
+  const resolveFrom = createRequire(path.join(root, 'noop.js'))
 
   const [remarkPlugins, rehypePlugins, recmaPlugins] = await Promise.all([
     resolvePlugins(userOptions.remarkPlugins ?? [], resolveFrom),
     resolvePlugins(userOptions.rehypePlugins ?? [], resolveFrom),
     resolvePlugins(userOptions.recmaPlugins ?? [], resolveFrom),
-  ]);
+  ])
 
   const compiled = await mdx.compile(
     { value: source, path: filePath },
@@ -213,7 +216,7 @@ export async function compileMdx(
           ? { providerImportSource: provider }
           : {}),
     },
-  );
+  )
 
-  return { code: compiled.toString() };
+  return { code: compiled.toString() }
 }