vite-node 0.17.1 → 0.19.0

package/cli.d.ts

@@ -0,0 +1,8 @@
+interface CliOptions {
+    files?: string[];
+    _?: string[];
+    root?: string;
+    config?: string;
+}
+
+export { CliOptions };

package/client.d.ts

@@ -0,0 +1,37 @@
+import { ViteNodeRunnerOptions, ModuleCache } from './types.js';
+
+declare const DEFAULT_REQUEST_STUBS: {
+    '/@vite/client': {
+        injectQuery: (id: string) => string;
+        createHotContext(): {
+            accept: () => void;
+            prune: () => void;
+        };
+        updateStyle(): void;
+    };
+};
+declare class ViteNodeRunner {
+    options: ViteNodeRunnerOptions;
+    root: string;
+    moduleCache: Map<string, ModuleCache>;
+    constructor(options: ViteNodeRunnerOptions);
+    executeFile(file: string): Promise<any>;
+    executeId(id: string): Promise<any>;
+    cachedRequest(rawId: string, callstack: string[]): Promise<any>;
+    directRequest(id: string, fsPath: string, callstack: string[]): Promise<any>;
+    prepareContext(context: Record<string, any>): Record<string, any>;
+    setCache(id: string, mod: Partial<ModuleCache>): void;
+    shouldResolveId(dep: string): boolean;
+    /**
+     * Define if a module should be interop-ed
+     * This function mostly for the ability to override by subclass
+     */
+    shouldInterop(path: string, mod: any): boolean;
+    /**
+     * Import a module and interop it
+     */
+    interopedImport(path: string): Promise<any>;
+    hasNestedDefault(target: any): any;
+}
+
+export { DEFAULT_REQUEST_STUBS, ViteNodeRunner };

package/dist/cli.cjs

@@ -3,16 +3,16 @@
 var events = require('events');
 var kolorist = require('kolorist');
 var vite = require('vite');
-var server = require('./chunk-server.cjs');
-var client = require('./chunk-client.cjs');
-var utils = require('./chunk-utils.cjs');
+var server = require('./server.cjs');
+var client = require('./client.cjs');
+var utils = require('./utils.cjs');
 var hmr = require('./chunk-hmr.cjs');
 require('pathe');
 require('debug');
 require('fs');
 require('mlly');
-require('module');
 require('url');
+require('module');
 require('vm');
 
 function toArr(any) {
@@ -628,7 +628,7 @@ class CAC extends events.EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.17.1";
+var version = "0.19.0";
 
 const cli = cac("vite-node");
 cli.version(version).option("-r, --root <path>", "Use specified root directory").option("-c, --config <path>", "Use specified config file").option("-w, --watch", 'Restart on file changes, similar to "nodemon"').option("--options <options>", "Use specified Vite server options").help();

package/dist/cli.d.ts

@@ -1,4 +1,4 @@
-import { e as ViteNodeServerOptions } from './types-b59fb161.js';
+import { e as ViteNodeServerOptions } from './types-de894284.js';
 
 interface CliOptions {
     root?: string;

package/dist/cli.mjs

@@ -1,16 +1,16 @@
 import { EventEmitter } from 'events';
 import { red } from 'kolorist';
 import { createServer } from 'vite';
-import { V as ViteNodeServer } from './chunk-server.mjs';
-import { V as ViteNodeRunner } from './chunk-client.mjs';
-import { t as toArray } from './chunk-utils.mjs';
+import { ViteNodeServer } from './server.mjs';
+import { ViteNodeRunner } from './client.mjs';
+import { toArray } from './utils.mjs';
 import { v as viteNodeHmrPlugin, c as createHotContext, h as handleMessage } from './chunk-hmr.mjs';
 import 'pathe';
 import 'debug';
 import 'fs';
 import 'mlly';
-import 'module';
 import 'url';
+import 'module';
 import 'vm';
 
 function toArr(any) {
@@ -626,7 +626,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.17.1";
+var version = "0.19.0";
 
 const cli = cac("vite-node");
 cli.version(version).option("-r, --root <path>", "Use specified root directory").option("-c, --config <path>", "Use specified config file").option("-w, --watch", 'Restart on file changes, similar to "nodemon"').option("--options <options>", "Use specified Vite server options").help();

package/dist/client.cjs

@@ -2,17 +2,284 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var client = require('./chunk-client.cjs');
-require('module');
-require('url');
-require('vm');
-require('pathe');
-require('mlly');
-require('debug');
-require('./chunk-utils.cjs');
+var module$1 = require('module');
+var url = require('url');
+var vm = require('vm');
+var pathe = require('pathe');
+var mlly = require('mlly');
+var createDebug = require('debug');
+var utils = require('./utils.cjs');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
 
-exports.DEFAULT_REQUEST_STUBS = client.DEFAULT_REQUEST_STUBS;
-exports.ModuleCacheMap = client.ModuleCacheMap;
-exports.ViteNodeRunner = client.ViteNodeRunner;
+var vm__default = /*#__PURE__*/_interopDefaultLegacy(vm);
+var createDebug__default = /*#__PURE__*/_interopDefaultLegacy(createDebug);
+
+const debugExecute = createDebug__default["default"]("vite-node:client:execute");
+const debugNative = createDebug__default["default"]("vite-node:client:native");
+const DEFAULT_REQUEST_STUBS = {
+  "/@vite/client": {
+    injectQuery: (id) => id,
+    createHotContext() {
+      return {
+        accept: () => {
+        },
+        prune: () => {
+        },
+        dispose: () => {
+        },
+        decline: () => {
+        },
+        invalidate: () => {
+        },
+        on: () => {
+        }
+      };
+    },
+    updateStyle(id, css) {
+      if (typeof document === "undefined")
+        return;
+      const element = document.getElementById(id);
+      if (element)
+        element.remove();
+      const head = document.querySelector("head");
+      const style = document.createElement("style");
+      style.setAttribute("type", "text/css");
+      style.id = id;
+      style.innerHTML = css;
+      head == null ? void 0 : head.appendChild(style);
+    }
+  }
+};
+class ModuleCacheMap extends Map {
+  normalizePath(fsPath) {
+    return utils.normalizeModuleId(fsPath);
+  }
+  set(fsPath, mod) {
+    fsPath = this.normalizePath(fsPath);
+    if (!super.has(fsPath))
+      super.set(fsPath, mod);
+    else
+      Object.assign(super.get(fsPath), mod);
+    return this;
+  }
+  get(fsPath) {
+    fsPath = this.normalizePath(fsPath);
+    return super.get(fsPath);
+  }
+  delete(fsPath) {
+    fsPath = this.normalizePath(fsPath);
+    return super.delete(fsPath);
+  }
+}
+class ViteNodeRunner {
+  constructor(options) {
+    this.options = options;
+    this.root = options.root ?? process.cwd();
+    this.moduleCache = options.moduleCache ?? new ModuleCacheMap();
+    this.debug = options.debug ?? (typeof process !== "undefined" ? !!process.env.VITE_NODE_DEBUG : false);
+  }
+  async executeFile(file) {
+    return await this.cachedRequest(`/@fs/${utils.slash(pathe.resolve(file))}`, []);
+  }
+  async executeId(id) {
+    return await this.cachedRequest(id, []);
+  }
+  async cachedRequest(rawId, callstack) {
+    var _a, _b, _c, _d;
+    const id = utils.normalizeRequestId(rawId, this.options.base);
+    const fsPath = utils.toFilePath(id, this.root);
+    if (callstack.includes(fsPath) && ((_a = this.moduleCache.get(fsPath)) == null ? void 0 : _a.exports))
+      return (_b = this.moduleCache.get(fsPath)) == null ? void 0 : _b.exports;
+    if ((_c = this.moduleCache.get(fsPath)) == null ? void 0 : _c.promise)
+      return (_d = this.moduleCache.get(fsPath)) == null ? void 0 : _d.promise;
+    const promise = this.directRequest(id, fsPath, callstack);
+    this.moduleCache.set(fsPath, { promise });
+    return await promise;
+  }
+  async directRequest(id, fsPath, _callstack) {
+    const callstack = [..._callstack, fsPath];
+    const request = async (dep) => {
+      var _a;
+      const fsPath2 = utils.toFilePath(utils.normalizeRequestId(dep, this.options.base), this.root);
+      const getStack = () => {
+        return `stack:
+${[...callstack, fsPath2].reverse().map((p) => `- ${p}`).join("\n")}`;
+      };
+      let debugTimer;
+      if (this.debug)
+        debugTimer = setTimeout(() => this.debugLog(() => `module ${fsPath2} takes over 2s to load.
+${getStack()}`), 2e3);
+      try {
+        if (callstack.includes(fsPath2)) {
+          this.debugLog(() => `circular dependency, ${getStack()}`);
+          const depExports = (_a = this.moduleCache.get(fsPath2)) == null ? void 0 : _a.exports;
+          if (depExports)
+            return depExports;
+          throw new Error(`[vite-node] Failed to resolve circular dependency, ${getStack()}`);
+        }
+        const mod = await this.cachedRequest(dep, callstack);
+        return mod;
+      } finally {
+        if (debugTimer)
+          clearTimeout(debugTimer);
+      }
+    };
+    Object.defineProperty(request, "callstack", { get: () => callstack });
+    const resolveId = async (dep, callstackPosition = 1) => {
+      if (this.options.resolveId && this.shouldResolveId(dep)) {
+        let importer = callstack[callstack.length - callstackPosition];
+        if (importer && importer.startsWith("mock:"))
+          importer = importer.slice(5);
+        const { id: id2 } = await this.options.resolveId(dep, importer) || {};
+        dep = id2 && pathe.isAbsolute(id2) ? utils.mergeSlashes(`/@fs/${id2}`) : id2 || dep;
+      }
+      return dep;
+    };
+    id = await resolveId(id, 2);
+    const requestStubs = this.options.requestStubs || DEFAULT_REQUEST_STUBS;
+    if (id in requestStubs)
+      return requestStubs[id];
+    let { code: transformed, externalize } = await this.options.fetchModule(id);
+    if (externalize) {
+      debugNative(externalize);
+      const mod = await this.interopedImport(externalize);
+      this.moduleCache.set(fsPath, { exports: mod });
+      return mod;
+    }
+    if (transformed == null)
+      throw new Error(`[vite-node] Failed to load ${id}`);
+    const url$1 = url.pathToFileURL(fsPath).href;
+    const meta = { url: url$1 };
+    const exports = /* @__PURE__ */ Object.create(null);
+    exports[Symbol.toStringTag] = "Module";
+    this.moduleCache.set(fsPath, { code: transformed, exports });
+    const __filename = url.fileURLToPath(url$1);
+    const moduleProxy = {
+      set exports(value) {
+        exportAll(exports, value);
+        exports.default = value;
+      },
+      get exports() {
+        return exports;
+      }
+    };
+    let hotContext;
+    if (this.options.createHotContext) {
+      Object.defineProperty(meta, "hot", {
+        enumerable: true,
+        get: () => {
+          var _a, _b;
+          hotContext || (hotContext = (_b = (_a = this.options).createHotContext) == null ? void 0 : _b.call(_a, this, `/@fs/${fsPath}`));
+          return hotContext;
+        }
+      });
+    }
+    const context = this.prepareContext({
+      __vite_ssr_import__: request,
+      __vite_ssr_dynamic_import__: request,
+      __vite_ssr_exports__: exports,
+      __vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
+      __vite_ssr_import_meta__: meta,
+      __vitest_resolve_id__: resolveId,
+      require: module$1.createRequire(url$1),
+      exports,
+      module: moduleProxy,
+      __filename,
+      __dirname: pathe.dirname(__filename)
+    });
+    debugExecute(__filename);
+    if (transformed[0] === "#")
+      transformed = transformed.replace(/^\#\!.*/, (s) => " ".repeat(s.length));
+    const fn = vm__default["default"].runInThisContext(`'use strict';async (${Object.keys(context).join(",")})=>{{${transformed}
+}}`, {
+      filename: fsPath,
+      lineOffset: 0
+    });
+    await fn(...Object.values(context));
+    return exports;
+  }
+  prepareContext(context) {
+    return context;
+  }
+  shouldResolveId(dep) {
+    if (mlly.isNodeBuiltin(dep) || dep in (this.options.requestStubs || DEFAULT_REQUEST_STUBS) || dep.startsWith("/@vite"))
+      return false;
+    return !pathe.isAbsolute(dep) || !pathe.extname(dep);
+  }
+  shouldInterop(path, mod) {
+    if (this.options.interopDefault === false)
+      return false;
+    return !path.endsWith(".mjs") && "default" in mod;
+  }
+  async interopedImport(path) {
+    const mod = await (function (t) { return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(t)); }); })(path);
+    if (this.shouldInterop(path, mod)) {
+      const tryDefault = this.hasNestedDefault(mod);
+      return new Proxy(mod, {
+        get: proxyMethod("get", tryDefault),
+        set: proxyMethod("set", tryDefault),
+        has: proxyMethod("has", tryDefault),
+        deleteProperty: proxyMethod("deleteProperty", tryDefault)
+      });
+    }
+    return mod;
+  }
+  hasNestedDefault(target) {
+    return "__esModule" in target && target.__esModule && "default" in target.default;
+  }
+  debugLog(msg) {
+    if (this.debug)
+      console.log(`[vite-node] ${msg()}`);
+  }
+}
+function proxyMethod(name, tryDefault) {
+  return function(target, key, ...args) {
+    const result = Reflect[name](target, key, ...args);
+    if (utils.isPrimitive(target.default))
+      return result;
+    if (tryDefault && key === "default" || typeof result === "undefined")
+      return Reflect[name](target.default, key, ...args);
+    return result;
+  };
+}
+function exportAll(exports, sourceModule) {
+  if (exports === sourceModule)
+    return;
+  for (const key in sourceModule) {
+    if (key !== "default") {
+      try {
+        Object.defineProperty(exports, key, {
+          enumerable: true,
+          configurable: true,
+          get() {
+            return sourceModule[key];
+          }
+        });
+      } catch (_err) {
+      }
+    }
+  }
+}
+
+exports.DEFAULT_REQUEST_STUBS = DEFAULT_REQUEST_STUBS;
+exports.ModuleCacheMap = ModuleCacheMap;
+exports.ViteNodeRunner = ViteNodeRunner;

package/dist/client.d.ts

@@ -1 +1 @@
-export { i as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, g as ViteNodeRunner } from './types-b59fb161.js';
+export { i as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, g as ViteNodeRunner } from './types-de894284.js';

package/dist/client.mjs

@@ -1,8 +1,256 @@
-export { D as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, V as ViteNodeRunner } from './chunk-client.mjs';
-import 'module';
-import 'url';
-import 'vm';
-import 'pathe';
-import 'mlly';
-import 'debug';
-import './chunk-utils.mjs';
+import { createRequire } from 'module';
+import { pathToFileURL, fileURLToPath } from 'url';
+import vm from 'vm';
+import { resolve, dirname, isAbsolute, extname } from 'pathe';
+import { isNodeBuiltin } from 'mlly';
+import createDebug from 'debug';
+import { normalizeModuleId, slash, normalizeRequestId, toFilePath, isPrimitive, mergeSlashes } from './utils.mjs';
+
+const debugExecute = createDebug("vite-node:client:execute");
+const debugNative = createDebug("vite-node:client:native");
+const DEFAULT_REQUEST_STUBS = {
+  "/@vite/client": {
+    injectQuery: (id) => id,
+    createHotContext() {
+      return {
+        accept: () => {
+        },
+        prune: () => {
+        },
+        dispose: () => {
+        },
+        decline: () => {
+        },
+        invalidate: () => {
+        },
+        on: () => {
+        }
+      };
+    },
+    updateStyle(id, css) {
+      if (typeof document === "undefined")
+        return;
+      const element = document.getElementById(id);
+      if (element)
+        element.remove();
+      const head = document.querySelector("head");
+      const style = document.createElement("style");
+      style.setAttribute("type", "text/css");
+      style.id = id;
+      style.innerHTML = css;
+      head == null ? void 0 : head.appendChild(style);
+    }
+  }
+};
+class ModuleCacheMap extends Map {
+  normalizePath(fsPath) {
+    return normalizeModuleId(fsPath);
+  }
+  set(fsPath, mod) {
+    fsPath = this.normalizePath(fsPath);
+    if (!super.has(fsPath))
+      super.set(fsPath, mod);
+    else
+      Object.assign(super.get(fsPath), mod);
+    return this;
+  }
+  get(fsPath) {
+    fsPath = this.normalizePath(fsPath);
+    return super.get(fsPath);
+  }
+  delete(fsPath) {
+    fsPath = this.normalizePath(fsPath);
+    return super.delete(fsPath);
+  }
+}
+class ViteNodeRunner {
+  constructor(options) {
+    this.options = options;
+    this.root = options.root ?? process.cwd();
+    this.moduleCache = options.moduleCache ?? new ModuleCacheMap();
+    this.debug = options.debug ?? (typeof process !== "undefined" ? !!process.env.VITE_NODE_DEBUG : false);
+  }
+  async executeFile(file) {
+    return await this.cachedRequest(`/@fs/${slash(resolve(file))}`, []);
+  }
+  async executeId(id) {
+    return await this.cachedRequest(id, []);
+  }
+  async cachedRequest(rawId, callstack) {
+    var _a, _b, _c, _d;
+    const id = normalizeRequestId(rawId, this.options.base);
+    const fsPath = toFilePath(id, this.root);
+    if (callstack.includes(fsPath) && ((_a = this.moduleCache.get(fsPath)) == null ? void 0 : _a.exports))
+      return (_b = this.moduleCache.get(fsPath)) == null ? void 0 : _b.exports;
+    if ((_c = this.moduleCache.get(fsPath)) == null ? void 0 : _c.promise)
+      return (_d = this.moduleCache.get(fsPath)) == null ? void 0 : _d.promise;
+    const promise = this.directRequest(id, fsPath, callstack);
+    this.moduleCache.set(fsPath, { promise });
+    return await promise;
+  }
+  async directRequest(id, fsPath, _callstack) {
+    const callstack = [..._callstack, fsPath];
+    const request = async (dep) => {
+      var _a;
+      const fsPath2 = toFilePath(normalizeRequestId(dep, this.options.base), this.root);
+      const getStack = () => {
+        return `stack:
+${[...callstack, fsPath2].reverse().map((p) => `- ${p}`).join("\n")}`;
+      };
+      let debugTimer;
+      if (this.debug)
+        debugTimer = setTimeout(() => this.debugLog(() => `module ${fsPath2} takes over 2s to load.
+${getStack()}`), 2e3);
+      try {
+        if (callstack.includes(fsPath2)) {
+          this.debugLog(() => `circular dependency, ${getStack()}`);
+          const depExports = (_a = this.moduleCache.get(fsPath2)) == null ? void 0 : _a.exports;
+          if (depExports)
+            return depExports;
+          throw new Error(`[vite-node] Failed to resolve circular dependency, ${getStack()}`);
+        }
+        const mod = await this.cachedRequest(dep, callstack);
+        return mod;
+      } finally {
+        if (debugTimer)
+          clearTimeout(debugTimer);
+      }
+    };
+    Object.defineProperty(request, "callstack", { get: () => callstack });
+    const resolveId = async (dep, callstackPosition = 1) => {
+      if (this.options.resolveId && this.shouldResolveId(dep)) {
+        let importer = callstack[callstack.length - callstackPosition];
+        if (importer && importer.startsWith("mock:"))
+          importer = importer.slice(5);
+        const { id: id2 } = await this.options.resolveId(dep, importer) || {};
+        dep = id2 && isAbsolute(id2) ? mergeSlashes(`/@fs/${id2}`) : id2 || dep;
+      }
+      return dep;
+    };
+    id = await resolveId(id, 2);
+    const requestStubs = this.options.requestStubs || DEFAULT_REQUEST_STUBS;
+    if (id in requestStubs)
+      return requestStubs[id];
+    let { code: transformed, externalize } = await this.options.fetchModule(id);
+    if (externalize) {
+      debugNative(externalize);
+      const mod = await this.interopedImport(externalize);
+      this.moduleCache.set(fsPath, { exports: mod });
+      return mod;
+    }
+    if (transformed == null)
+      throw new Error(`[vite-node] Failed to load ${id}`);
+    const url = pathToFileURL(fsPath).href;
+    const meta = { url };
+    const exports = /* @__PURE__ */ Object.create(null);
+    exports[Symbol.toStringTag] = "Module";
+    this.moduleCache.set(fsPath, { code: transformed, exports });
+    const __filename = fileURLToPath(url);
+    const moduleProxy = {
+      set exports(value) {
+        exportAll(exports, value);
+        exports.default = value;
+      },
+      get exports() {
+        return exports;
+      }
+    };
+    let hotContext;
+    if (this.options.createHotContext) {
+      Object.defineProperty(meta, "hot", {
+        enumerable: true,
+        get: () => {
+          var _a, _b;
+          hotContext || (hotContext = (_b = (_a = this.options).createHotContext) == null ? void 0 : _b.call(_a, this, `/@fs/${fsPath}`));
+          return hotContext;
+        }
+      });
+    }
+    const context = this.prepareContext({
+      __vite_ssr_import__: request,
+      __vite_ssr_dynamic_import__: request,
+      __vite_ssr_exports__: exports,
+      __vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
+      __vite_ssr_import_meta__: meta,
+      __vitest_resolve_id__: resolveId,
+      require: createRequire(url),
+      exports,
+      module: moduleProxy,
+      __filename,
+      __dirname: dirname(__filename)
+    });
+    debugExecute(__filename);
+    if (transformed[0] === "#")
+      transformed = transformed.replace(/^\#\!.*/, (s) => " ".repeat(s.length));
+    const fn = vm.runInThisContext(`'use strict';async (${Object.keys(context).join(",")})=>{{${transformed}
+}}`, {
+      filename: fsPath,
+      lineOffset: 0
+    });
+    await fn(...Object.values(context));
+    return exports;
+  }
+  prepareContext(context) {
+    return context;
+  }
+  shouldResolveId(dep) {
+    if (isNodeBuiltin(dep) || dep in (this.options.requestStubs || DEFAULT_REQUEST_STUBS) || dep.startsWith("/@vite"))
+      return false;
+    return !isAbsolute(dep) || !extname(dep);
+  }
+  shouldInterop(path, mod) {
+    if (this.options.interopDefault === false)
+      return false;
+    return !path.endsWith(".mjs") && "default" in mod;
+  }
+  async interopedImport(path) {
+    const mod = await import(path);
+    if (this.shouldInterop(path, mod)) {
+      const tryDefault = this.hasNestedDefault(mod);
+      return new Proxy(mod, {
+        get: proxyMethod("get", tryDefault),
+        set: proxyMethod("set", tryDefault),
+        has: proxyMethod("has", tryDefault),
+        deleteProperty: proxyMethod("deleteProperty", tryDefault)
+      });
+    }
+    return mod;
+  }
+  hasNestedDefault(target) {
+    return "__esModule" in target && target.__esModule && "default" in target.default;
+  }
+  debugLog(msg) {
+    if (this.debug)
+      console.log(`[vite-node] ${msg()}`);
+  }
+}
+function proxyMethod(name, tryDefault) {
+  return function(target, key, ...args) {
+    const result = Reflect[name](target, key, ...args);
+    if (isPrimitive(target.default))
+      return result;
+    if (tryDefault && key === "default" || typeof result === "undefined")
+      return Reflect[name](target.default, key, ...args);
+    return result;
+  };
+}
+function exportAll(exports, sourceModule) {
+  if (exports === sourceModule)
+    return;
+  for (const key in sourceModule) {
+    if (key !== "default") {
+      try {
+        Object.defineProperty(exports, key, {
+          enumerable: true,
+          configurable: true,
+          get() {
+            return sourceModule[key];
+          }
+        });
+      } catch (_err) {
+      }
+    }
+  }
+}
+
+export { DEFAULT_REQUEST_STUBS, ModuleCacheMap, ViteNodeRunner };

package/dist/hmr.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
 import { HMRPayload, Plugin } from 'vite';
-import { U as UpdatePayload, P as PrunePayload, f as FullReloadPayload, E as ErrorPayload, g as ViteNodeRunner, h as HMRPayload$1, H as HotContext } from './types-b59fb161.js';
+import { U as UpdatePayload, P as PrunePayload, f as FullReloadPayload, E as ErrorPayload, g as ViteNodeRunner, h as HMRPayload$1, H as HotContext } from './types-de894284.js';
 
 declare type EventType = string | symbol;
 declare type Handler<T = unknown> = (event: T) => void;

package/dist/index.d.ts

@@ -1 +1 @@
-export { A as Arrayable, C as CreateHotContextFunction, D as DepsHandlingOptions, a as FetchFunction, F as FetchResult, H as HotContext, c as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, b as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, V as ViteNodeRunnerOptions, e as ViteNodeServerOptions } from './types-b59fb161.js';
+export { A as Arrayable, C as CreateHotContextFunction, D as DepsHandlingOptions, a as FetchFunction, F as FetchResult, H as HotContext, c as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, b as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, V as ViteNodeRunnerOptions, e as ViteNodeServerOptions } from './types-de894284.js';