vite 6.0.0-alpha.2 → 6.0.0-alpha.3

package/dist/node/index.js

@@ -1,17 +1,16 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-E4cF1RpV.js';
-export { B as BuildEnvironment, D as DevEnvironment, b as build, h as buildErrorMessage, u as createFilter, x as createLogger, j as createNodeDevEnvironment, c as createServer, e as createViteBuilder, d as defineConfig, k as fetchModule, f as formatPostcssSourceMap, z as isFileServingAllowed, l as loadConfigFromFile, A as loadEnv, q as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, g as preprocessCSS, p as preview, r as resolveConfig, C as resolveEnvPrefix, v as rollupVersion, y as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-E4cF1RpV.js';
-import { existsSync, readFileSync } from 'node:fs';
-import { ModuleRunner, ESModulesEvaluator } from 'vite/module-runner';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-DitPlFWl.js';
+export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, b as build, h as buildErrorMessage, u as createFilter, j as createNodeDevEnvironment, c as createServer, m as createServerModuleRunner, e as createViteBuilder, d as defineConfig, k as fetchModule, f as formatPostcssSourceMap, y as isFileServingAllowed, l as loadConfigFromFile, z as loadEnv, q as mergeAlias, o as mergeConfig, n as normalizePath, g as preprocessCSS, p as preview, r as resolveConfig, A as resolveEnvPrefix, v as rollupVersion, x as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-DitPlFWl.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
+export { c as createLogger } from './chunks/dep-C7zR1Rh8.js';
+import 'node:fs';
 import 'node:fs/promises';
 import 'node:path';
 import 'node:url';
 import 'node:util';
 import 'node:perf_hooks';
 import 'node:module';
-import 'tty';
 import 'path';
 import 'fs';
 import 'events';
@@ -19,6 +18,7 @@ import 'assert';
 import 'node:child_process';
 import 'node:http';
 import 'node:https';
+import 'tty';
 import 'util';
 import 'net';
 import 'url';
@@ -29,19 +29,20 @@ import 'child_process';
 import 'node:os';
 import 'node:crypto';
 import 'node:dns';
+import 'vite/module-runner';
+import 'module';
 import 'node:assert';
 import 'node:v8';
-import 'module';
 import 'node:worker_threads';
 import 'node:events';
 import 'crypto';
+import 'querystring';
 import 'node:buffer';
 import 'node:readline';
 import 'zlib';
 import 'buffer';
 import 'https';
 import 'tls';
-import 'querystring';
 import 'node:zlib';
 
 // This file will be built for both ESM and CJS. Avoid relying on other modules as possible.
@@ -199,116 +200,4 @@ class RemoteEnvironmentTransport {
     }
 }
 
-class ServerHMRBroadcasterClient {
-    hmrChannel;
-    constructor(hmrChannel) {
-        this.hmrChannel = hmrChannel;
-    }
-    send(...args) {
-        let payload;
-        if (typeof args[0] === 'string') {
-            payload = {
-                type: 'custom',
-                event: args[0],
-                data: args[1],
-            };
-        }
-        else {
-            payload = args[0];
-        }
-        if (payload.type !== 'custom') {
-            throw new Error('Cannot send non-custom events from the client to the server.');
-        }
-        this.hmrChannel.send(payload);
-    }
-}
-/**
- * The connector class to establish HMR communication between the server and the Vite runtime.
- * @experimental
- */
-class ServerHMRConnector {
-    handlers = [];
-    hmrChannel;
-    hmrClient;
-    connected = false;
-    constructor(server) {
-        const hmrChannel = server.hot?.channels.find((c) => c.name === 'ssr');
-        if (!hmrChannel) {
-            throw new Error("Your version of Vite doesn't support HMR during SSR. Please, use Vite 5.1 or higher.");
-        }
-        this.hmrClient = new ServerHMRBroadcasterClient(hmrChannel);
-        hmrChannel.api.outsideEmitter.on('send', (payload) => {
-            this.handlers.forEach((listener) => listener(payload));
-        });
-        this.hmrChannel = hmrChannel;
-    }
-    isReady() {
-        return this.connected;
-    }
-    send(message) {
-        const payload = JSON.parse(message);
-        this.hmrChannel.api.innerEmitter.emit(payload.event, payload.data, this.hmrClient);
-    }
-    onUpdate(handler) {
-        this.handlers.push(handler);
-        handler({ type: 'connected' });
-        this.connected = true;
-    }
-}
-
-function createHMROptions(server, options) {
-    if (server.config.server.hmr === false || options.hmr === false) {
-        return false;
-    }
-    if (options.hmr?.connection) {
-        return {
-            connection: options.hmr.connection,
-            logger: options.hmr.logger,
-        };
-    }
-    const connection = new ServerHMRConnector(server);
-    return {
-        connection,
-        logger: options.hmr?.logger,
-    };
-}
-const prepareStackTrace = {
-    retrieveFile(id) {
-        if (existsSync(id)) {
-            return readFileSync(id, 'utf-8');
-        }
-    },
-};
-function resolveSourceMapOptions(options) {
-    if (options.sourcemapInterceptor != null) {
-        if (options.sourcemapInterceptor === 'prepareStackTrace') {
-            return prepareStackTrace;
-        }
-        if (typeof options.sourcemapInterceptor === 'object') {
-            return { ...prepareStackTrace, ...options.sourcemapInterceptor };
-        }
-        return options.sourcemapInterceptor;
-    }
-    if (typeof process !== 'undefined' && 'setSourceMapsEnabled' in process) {
-        return 'node';
-    }
-    return prepareStackTrace;
-}
-/**
- * Create an instance of the Vite SSR runtime that support HMR.
- * @experimental
- */
-function createServerModuleRunner(environment, options = {}) {
-    const hmr = createHMROptions(environment.server, options);
-    return new ModuleRunner({
-        ...options,
-        root: environment.config.root,
-        transport: {
-            fetchModule: (id, importer) => environment.fetchModule(id, importer),
-        },
-        hmr,
-        sourcemapInterceptor: resolveSourceMapOptions(options),
-    }, options.runner || new ESModulesEvaluator());
-}
-
-export { RemoteEnvironmentTransport, ServerHMRConnector, createServerModuleRunner, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };
+export { RemoteEnvironmentTransport, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };

package/dist/node/module-runner.d.ts

@@ -117,12 +117,12 @@ declare class ModuleRunner {
      */
     moduleCache: ModuleCacheMap;
     hmrClient?: HMRClient;
-    private idToUrlMap;
-    private fileToIdMap;
-    private envProxy;
-    private transport;
-    private _destroyed;
-    private _resetSourceMapSupport?;
+    private readonly urlToIdMap;
+    private readonly fileToIdMap;
+    private readonly envProxy;
+    private readonly transport;
+    private readonly resetSourceMapSupport?;
+    private destroyed;
     constructor(options: ModuleRunnerOptions, evaluator: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
     /**
      * URL to execute. Accepts file path, server path or id relative to the root.
@@ -141,12 +141,11 @@ declare class ModuleRunner {
      * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
      */
     isDestroyed(): boolean;
-    private invalidateFiles;
     private normalizeEntryUrl;
     private processImport;
     private cachedRequest;
     private cachedModule;
-    protected directRequest(id: string, fetchResult: ResolvedResult, _callstack: string[]): Promise<any>;
+    protected directRequest(id: string, mod: ModuleCache, _callstack: string[]): Promise<any>;
 }
 
 interface RetrieveFileHandler {
@@ -217,7 +216,8 @@ interface ModuleCache {
     exports?: any;
     evaluated?: boolean;
     map?: DecodedMap;
-    meta?: FetchResult;
+    meta?: ResolvedResult;
+    timestamp?: number;
     /**
      * Module ids that imports this module
      */
@@ -314,7 +314,8 @@ declare class ModuleCacheMap extends Map<string, ModuleCache> {
     get(fsPath: string): ModuleCache;
     deleteByModuleId(modulePath: string): boolean;
     delete(fsPath: string): boolean;
-    invalidate(id: string): void;
+    invalidateUrl(id: string): void;
+    invalidateModule(module: ModuleCache): void;
     /**
      * Invalidate modules that dependent on the given modules, up to the main entry
      */

package/dist/node/module-runner.js

@@ -77,7 +77,15 @@ const isAbsolute = function(p) {
 }, dirname = function(p) {
   const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
   return segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0]) && (segments[0] += "/"), segments.join("/") || (isAbsolute(p) ? "/" : ".");
-}, decodeBase64 = typeof atob < "u" ? atob : (str) => Buffer.from(str, "base64").toString("utf-8"), CHAR_FORWARD_SLASH = 47, CHAR_BACKWARD_SLASH = 92, percentRegEx = /%/g, backslashRegEx = /\\/g, newlineRegEx = /\n/g, carriageReturnRegEx = /\r/g, tabRegEx = /\t/g, questionRegex = /\?/g, hashRegex = /#/g;
+}, decodeBase64 = typeof atob < "u" ? atob : (str) => Buffer.from(str, "base64").toString("utf-8"), CHAR_FORWARD_SLASH = 47, CHAR_BACKWARD_SLASH = 92, percentRegEx = /%/g, backslashRegEx = /\\/g, newlineRegEx = /\n/g, carriageReturnRegEx = /\r/g, tabRegEx = /\t/g, questionRegex = /\?/g, hashRegex = /#/g, timestampRegex = /[?&]t=(\d{13})(&?)/;
+function parseUrl(url) {
+  const idQuery = url.split("?")[1];
+  let timestamp = 0;
+  return {
+    query: idQuery ? ("?" + idQuery).replace(timestampRegex, (substring, tsString, nextItem) => (timestamp = Number(tsString), substring[0] === "?" && nextItem === "&" ? "?" : "")) : "",
+    timestamp
+  };
+}
 function encodePathChars(filepath) {
   return filepath.indexOf("%") !== -1 && (filepath = filepath.replace(percentRegEx, "%25")), !isWindows && filepath.indexOf("\\") !== -1 && (filepath = filepath.replace(backslashRegEx, "%5C")), filepath.indexOf(`
 `) !== -1 && (filepath = filepath.replace(newlineRegEx, "%0A")), filepath.indexOf("\r") !== -1 && (filepath = filepath.replace(carriageReturnRegEx, "%0D")), filepath.indexOf("	") !== -1 && (filepath = filepath.replace(tabRegEx, "%09")), filepath;
@@ -251,7 +259,8 @@ class ModuleCacheMap extends Map {
     const mod = super.get(modulePath);
     return mod.imports || Object.assign(mod, {
       imports: /* @__PURE__ */ new Set(),
-      importers: /* @__PURE__ */ new Set()
+      importers: /* @__PURE__ */ new Set(),
+      timestamp: 0
     }), mod;
   }
   get(fsPath) {
@@ -263,8 +272,11 @@ class ModuleCacheMap extends Map {
   delete(fsPath) {
     return this.deleteByModuleId(this.normalize(fsPath));
   }
-  invalidate(id) {
+  invalidateUrl(id) {
     const module = this.get(id);
+    this.invalidateModule(module);
+  }
+  invalidateModule(module) {
     module.evaluated = !1, module.meta = void 0, module.map = void 0, module.promise = void 0, module.exports = void 0, module.imports?.clear();
   }
   /**
@@ -277,7 +289,7 @@ class ModuleCacheMap extends Map {
         continue;
       invalidated.add(id);
       const mod = super.get(id);
-      mod?.importers && this.invalidateDepTree(mod.importers, invalidated), this.invalidate(id);
+      mod?.importers && this.invalidateDepTree(mod.importers, invalidated), this.invalidateUrl(id);
     }
     return invalidated;
   }
@@ -366,7 +378,7 @@ class HMRContext {
     }), this.send("vite:invalidate", {
       path: this.ownerPath,
       message
-    }), this.hmrClient.logger.debug(`[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`);
+    }), this.hmrClient.logger.debug(`invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`);
   }
   on(event, cb) {
     const addToMap = (map) => {
@@ -451,7 +463,7 @@ class HMRClient {
     });
   }
   warnFailedUpdate(err, path) {
-    err.message.includes("fetch") || this.logger.error(err), this.logger.error(`[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
+    err.message.includes("fetch") || this.logger.error(err), this.logger.error(`Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
   }
   updateQueue = [];
   pendingUpdateQueue = !1;
@@ -486,7 +498,7 @@ class HMRClient {
       for (const { deps, fn } of qualifiedCallbacks)
         fn(deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0));
       const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
-      this.logger.debug(`[vite] hot updated: ${loggedPath}`);
+      this.logger.debug(`hot updated: ${loggedPath}`);
     };
   }
 }
@@ -517,6 +529,9 @@ const ssrModuleExportsKey = "__vite_ssr_exports__", ssrImportKey = "__vite_ssr_i
 }, silentConsole = {
   debug: noop,
   error: noop
+}, hmrLogger = {
+  debug: (...msg) => console.log("[vite]", ...msg),
+  error: (error) => console.log("[vite]", error)
 };
 function createHMRHandler(runner) {
   const queue = new Queue();
@@ -527,13 +542,13 @@ async function handleHMRPayload(runner, payload) {
   if (!(!hmrClient || runner.isDestroyed()))
     switch (payload.type) {
       case "connected":
-        hmrClient.logger.debug("[vite] connected."), hmrClient.messenger.flush();
+        hmrClient.logger.debug("connected."), hmrClient.messenger.flush();
         break;
       case "update":
         await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(payload.updates.map(async (update) => {
           if (update.type === "js-update")
             return update.acceptedPath = unwrapId(update.acceptedPath), update.path = unwrapId(update.path), hmrClient.queueUpdate(update);
-          hmrClient.logger.error("[vite] css hmr is not supported in runner mode.");
+          hmrClient.logger.error("css hmr is not supported in runner mode.");
         })), await hmrClient.notifyListeners("vite:afterUpdate", payload);
         break;
       case "custom": {
@@ -544,7 +559,7 @@ async function handleHMRPayload(runner, payload) {
         const { triggeredBy } = payload, clearEntrypoints = triggeredBy ? getModulesEntrypoints(runner, getModulesByFile(runner, slash(triggeredBy))) : findAllEntrypoints(runner);
         if (!clearEntrypoints.size)
           break;
-        hmrClient.logger.debug("[vite] program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.moduleCache.clear();
+        hmrClient.logger.debug("program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.moduleCache.clear();
         for (const id of clearEntrypoints)
           await runner.import(id);
         break;
@@ -555,7 +570,7 @@ async function handleHMRPayload(runner, payload) {
       case "error": {
         await hmrClient.notifyListeners("vite:error", payload);
         const err = payload.err;
-        hmrClient.logger.error(`[vite] Internal Server Error
+        hmrClient.logger.error(`Internal Server Error
 ${err.message}
 ${err.stack}`);
         break;
@@ -826,7 +841,7 @@ class ModuleRunner {
    */
   moduleCache;
   hmrClient;
-  idToUrlMap = /* @__PURE__ */ new Map();
+  urlToIdMap = /* @__PURE__ */ new Map();
   fileToIdMap = /* @__PURE__ */ new Map();
   envProxy = new Proxy({}, {
     get(_, p) {
@@ -834,10 +849,13 @@ class ModuleRunner {
     }
   });
   transport;
-  _destroyed = !1;
-  _resetSourceMapSupport;
+  resetSourceMapSupport;
+  destroyed = !1;
   constructor(options, evaluator, debug) {
-    this.options = options, this.evaluator = evaluator, this.debug = debug, this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root), this.transport = options.transport, typeof options.hmr == "object" && (this.hmrClient = new HMRClient(options.hmr.logger === !1 ? silentConsole : options.hmr.logger || console, options.hmr.connection, ({ acceptedPath, invalidates }) => (this.moduleCache.invalidate(acceptedPath), invalidates && this.invalidateFiles(invalidates), this.import(acceptedPath))), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== !1 && (this._resetSourceMapSupport = enableSourceMapSupport(this));
+    this.options = options, this.evaluator = evaluator, this.debug = debug, this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root), this.transport = options.transport, typeof options.hmr == "object" && (this.hmrClient = new HMRClient(options.hmr.logger === !1 ? silentConsole : options.hmr.logger || hmrLogger, options.hmr.connection, ({ acceptedPath, explicitImportRequired, timestamp }) => {
+      const [acceptedPathWithoutQuery, query] = acceptedPath.split("?"), url = acceptedPathWithoutQuery + `?${explicitImportRequired ? "import&" : ""}t=${timestamp}${query ? `&${query}` : ""}`;
+      return this.import(url);
+    }), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== !1 && (this.resetSourceMapSupport = enableSourceMapSupport(this));
   }
   /**
    * URL to execute. Accepts file path, server path or id relative to the root.
@@ -851,27 +869,20 @@ class ModuleRunner {
    * Clear all caches including HMR listeners.
    */
   clearCache() {
-    this.moduleCache.clear(), this.idToUrlMap.clear(), this.hmrClient?.clear();
+    this.moduleCache.clear(), this.urlToIdMap.clear(), this.hmrClient?.clear();
   }
   /**
    * Clears all caches, removes all HMR listeners, and resets source map support.
    * This method doesn't stop the HMR connection.
    */
   async destroy() {
-    this._resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this._destroyed = !0;
+    this.resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this.destroyed = !0;
   }
   /**
    * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
    */
   isDestroyed() {
-    return this._destroyed;
-  }
-  // map files to modules and invalidate them
-  invalidateFiles(files) {
-    files.forEach((file) => {
-      const ids = this.fileToIdMap.get(file);
-      ids && ids.forEach((id) => this.moduleCache.invalidate(id));
-    });
+    return this.destroyed;
   }
   // we don't use moduleCache.normalize because this URL doesn't have to follow the same rules
   // this URL is something that user passes down manually, and is later resolved by fetchModule
@@ -889,10 +900,10 @@ class ModuleRunner {
     const { id, type } = fetchResult;
     return type !== "module" && type !== "commonjs" ? exports : (analyzeImportedModDifference(exports, id, type, metadata), proxyGuardOnlyEsm(exports, id, metadata));
   }
-  async cachedRequest(id, fetchedModule, callstack = [], metadata) {
-    const moduleId = fetchedModule.id, mod = this.moduleCache.getByModuleId(moduleId), { imports, importers } = mod, importee = callstack[callstack.length - 1];
+  async cachedRequest(id, mod, callstack = [], metadata) {
+    const meta = mod.meta, moduleId = meta.id, { imports, importers } = mod, importee = callstack[callstack.length - 1];
     if (importee && importers.add(importee), (callstack.includes(moduleId) || Array.from(imports.values()).some((i) => importers.has(i))) && mod.exports)
-      return this.processImport(mod.exports, fetchedModule, metadata);
+      return this.processImport(mod.exports, meta, metadata);
     let debugTimer;
     this.debug && (debugTimer = setTimeout(() => {
       const getStack = () => `stack:
@@ -903,35 +914,35 @@ ${getStack()}`);
     }, 2e3));
     try {
       if (mod.promise)
-        return this.processImport(await mod.promise, fetchedModule, metadata);
-      const promise = this.directRequest(id, fetchedModule, callstack);
-      return mod.promise = promise, mod.evaluated = !1, this.processImport(await promise, fetchedModule, metadata);
+        return this.processImport(await mod.promise, meta, metadata);
+      const promise = this.directRequest(id, mod, callstack);
+      return mod.promise = promise, mod.evaluated = !1, this.processImport(await promise, meta, metadata);
     } finally {
       mod.evaluated = !0, debugTimer && clearTimeout(debugTimer);
     }
   }
-  async cachedModule(id, importer) {
-    if (this._destroyed)
-      throw new Error("[vite] Vite runtime has been destroyed.");
-    const normalized = this.idToUrlMap.get(id);
+  async cachedModule(url, importer) {
+    if (this.destroyed)
+      throw new Error("Vite module runner has been destroyed.");
+    const normalized = this.urlToIdMap.get(url);
     if (normalized) {
       const mod2 = this.moduleCache.getByModuleId(normalized);
       if (mod2.meta)
-        return mod2.meta;
+        return mod2;
     }
-    this.debug?.("[module runner] fetching", id);
-    const fetchedModule = id.startsWith("data:") ? { externalize: id, type: "builtin" } : await this.transport.fetchModule(id, importer), idQuery = id.split("?")[1], query = idQuery ? `?${idQuery}` : "", file = "file" in fetchedModule ? fetchedModule.file : void 0, fullFile = file ? `${file}${query}` : id, moduleId = this.moduleCache.normalize(fullFile), mod = this.moduleCache.getByModuleId(moduleId);
-    if (fetchedModule.id = moduleId, mod.meta = fetchedModule, file) {
+    this.debug?.("[module runner] fetching", url);
+    const fetchedModule = url.startsWith("data:") ? { externalize: url, type: "builtin" } : await this.transport.fetchModule(url, importer), { query, timestamp } = parseUrl(url), file = "file" in fetchedModule ? fetchedModule.file : void 0, fileId = file ? `${file}${query}` : url, moduleId = this.moduleCache.normalize(fileId), mod = this.moduleCache.getByModuleId(moduleId);
+    if (mod.timestamp != null && timestamp > 0 && mod.timestamp < timestamp && this.moduleCache.invalidateModule(mod), fetchedModule.id = moduleId, mod.meta = fetchedModule, mod.timestamp = timestamp, file) {
       const fileModules = this.fileToIdMap.get(file) || [];
       fileModules.push(moduleId), this.fileToIdMap.set(file, fileModules);
     }
-    return this.idToUrlMap.set(id, moduleId), this.idToUrlMap.set(unwrapId(id), moduleId), fetchedModule;
+    return this.urlToIdMap.set(url, moduleId), this.urlToIdMap.set(unwrapId(url), moduleId), mod;
   }
   // override is allowed, consider this a public API
-  async directRequest(id, fetchResult, _callstack) {
-    const moduleId = fetchResult.id, callstack = [..._callstack, moduleId], mod = this.moduleCache.getByModuleId(moduleId), request = async (dep, metadata) => {
-      const fetchedModule = await this.cachedModule(dep, moduleId);
-      return this.moduleCache.getByModuleId(fetchedModule.id).importers.add(moduleId), mod.imports.add(fetchedModule.id), this.cachedRequest(dep, fetchedModule, callstack, metadata);
+  async directRequest(id, mod, _callstack) {
+    const fetchResult = mod.meta, moduleId = fetchResult.id, callstack = [..._callstack, moduleId], request = async (dep, metadata) => {
+      const importer = "file" in fetchResult && fetchResult.file || moduleId, fetchedModule = await this.cachedModule(dep, importer), resolvedId = fetchedModule.meta.id;
+      return this.moduleCache.getByModuleId(resolvedId).importers.add(moduleId), mod.imports.add(resolvedId), this.cachedRequest(dep, fetchedModule, callstack, metadata);
     }, dynamicRequest = async (dep) => (dep = String(dep), dep[0] === "." && (dep = posixResolve(posixDirname(id), dep)), request(dep, { isDynamicImport: !0 }));
     if ("externalize" in fetchResult) {
       const { externalize } = fetchResult;