vite-node 0.34.3 → 0.34.5

package/dist/hmr.mjs

@@ -1,9 +1,241 @@
-export { a as createHmrEmitter, c as createHotContext, g as getCache, h as handleMessage, r as reload, s as sendMessageBuffer, v as viteNodeHmrPlugin } from './chunk-hmr.mjs';
-import 'node:events';
-import 'picocolors';
-import 'debug';
-import './utils.mjs';
+import { EventEmitter } from 'node:events';
+import c from 'picocolors';
+import createDebug from 'debug';
+import { normalizeRequestId } from './utils.mjs';
 import 'node:url';
 import 'node:module';
 import 'node:fs';
 import 'pathe';
+
+function createHmrEmitter() {
+  const emitter = new EventEmitter();
+  return emitter;
+}
+function viteNodeHmrPlugin() {
+  const emitter = createHmrEmitter();
+  return {
+    name: "vite-node:hmr",
+    config() {
+      if (process.platform === "darwin" && process.env.VITE_TEST_WATCHER_DEBUG) {
+        return {
+          server: {
+            watch: {
+              useFsEvents: false,
+              usePolling: false
+            }
+          }
+        };
+      }
+    },
+    configureServer(server) {
+      const _send = server.ws.send;
+      server.emitter = emitter;
+      server.ws.send = function(payload) {
+        _send(payload);
+        emitter.emit("message", payload);
+      };
+      if (process.env.VITE_TEST_WATCHER_DEBUG) {
+        server.watcher.on("ready", () => {
+          console.log("[debug] watcher is ready");
+        });
+      }
+    }
+  };
+}
+
+const debugHmr = createDebug("vite-node:hmr");
+const cache = /* @__PURE__ */ new WeakMap();
+function getCache(runner) {
+  if (!cache.has(runner)) {
+    cache.set(runner, {
+      hotModulesMap: /* @__PURE__ */ new Map(),
+      dataMap: /* @__PURE__ */ new Map(),
+      disposeMap: /* @__PURE__ */ new Map(),
+      pruneMap: /* @__PURE__ */ new Map(),
+      customListenersMap: /* @__PURE__ */ new Map(),
+      ctxToListenersMap: /* @__PURE__ */ new Map(),
+      messageBuffer: [],
+      isFirstUpdate: false,
+      pending: false,
+      queued: []
+    });
+  }
+  return cache.get(runner);
+}
+function sendMessageBuffer(runner, emitter) {
+  const maps = getCache(runner);
+  maps.messageBuffer.forEach((msg) => emitter.emit("custom", msg));
+  maps.messageBuffer.length = 0;
+}
+async function reload(runner, files) {
+  Array.from(runner.moduleCache.keys()).forEach((fsPath) => {
+    if (!fsPath.includes("node_modules"))
+      runner.moduleCache.delete(fsPath);
+  });
+  return Promise.all(files.map((file) => runner.executeId(file)));
+}
+async function notifyListeners(runner, event, data) {
+  const maps = getCache(runner);
+  const cbs = maps.customListenersMap.get(event);
+  if (cbs)
+    await Promise.all(cbs.map((cb) => cb(data)));
+}
+async function queueUpdate(runner, p) {
+  const maps = getCache(runner);
+  maps.queued.push(p);
+  if (!maps.pending) {
+    maps.pending = true;
+    await Promise.resolve();
+    maps.pending = false;
+    const loading = [...maps.queued];
+    maps.queued = [];
+    (await Promise.all(loading)).forEach((fn) => fn && fn());
+  }
+}
+async function fetchUpdate(runner, { path, acceptedPath }) {
+  path = normalizeRequestId(path);
+  acceptedPath = normalizeRequestId(acceptedPath);
+  const maps = getCache(runner);
+  const mod = maps.hotModulesMap.get(path);
+  if (!mod) {
+    return;
+  }
+  const isSelfUpdate = path === acceptedPath;
+  let fetchedModule;
+  const qualifiedCallbacks = mod.callbacks.filter(
+    ({ deps }) => deps.includes(acceptedPath)
+  );
+  if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+    const disposer = maps.disposeMap.get(acceptedPath);
+    if (disposer)
+      await disposer(maps.dataMap.get(acceptedPath));
+    try {
+      [fetchedModule] = await reload(runner, [acceptedPath]);
+    } catch (e) {
+      warnFailedFetch(e, acceptedPath);
+    }
+  }
+  return () => {
+    for (const { deps, fn } of qualifiedCallbacks)
+      fn(deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0));
+    const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+    console.log(`${c.cyan("[vite-node]")} hot updated: ${loggedPath}`);
+  };
+}
+function warnFailedFetch(err, path) {
+  if (!err.message.match("fetch"))
+    console.error(err);
+  console.error(
+    `[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`
+  );
+}
+async function handleMessage(runner, emitter, files, payload) {
+  const maps = getCache(runner);
+  switch (payload.type) {
+    case "connected":
+      sendMessageBuffer(runner, emitter);
+      break;
+    case "update":
+      await notifyListeners(runner, "vite:beforeUpdate", payload);
+      await Promise.all(payload.updates.map((update) => {
+        if (update.type === "js-update")
+          return queueUpdate(runner, fetchUpdate(runner, update));
+        console.error(`${c.cyan("[vite-node]")} no support css hmr.}`);
+        return null;
+      }));
+      await notifyListeners(runner, "vite:afterUpdate", payload);
+      break;
+    case "full-reload":
+      await notifyListeners(runner, "vite:beforeFullReload", payload);
+      maps.customListenersMap.delete("vite:beforeFullReload");
+      await reload(runner, files);
+      break;
+    case "custom":
+      await notifyListeners(runner, payload.event, payload.data);
+      break;
+    case "prune":
+      await notifyListeners(runner, "vite:beforePrune", payload);
+      payload.paths.forEach((path) => {
+        const fn = maps.pruneMap.get(path);
+        if (fn)
+          fn(maps.dataMap.get(path));
+      });
+      break;
+    case "error": {
+      await notifyListeners(runner, "vite:error", payload);
+      const err = payload.err;
+      console.error(`${c.cyan("[vite-node]")} Internal Server Error
+${err.message}
+${err.stack}`);
+      break;
+    }
+  }
+}
+function createHotContext(runner, emitter, files, ownerPath) {
+  debugHmr("createHotContext", ownerPath);
+  const maps = getCache(runner);
+  if (!maps.dataMap.has(ownerPath))
+    maps.dataMap.set(ownerPath, {});
+  const mod = maps.hotModulesMap.get(ownerPath);
+  if (mod)
+    mod.callbacks = [];
+  const newListeners = /* @__PURE__ */ new Map();
+  maps.ctxToListenersMap.set(ownerPath, newListeners);
+  function acceptDeps(deps, callback = () => {
+  }) {
+    const mod2 = maps.hotModulesMap.get(ownerPath) || {
+      id: ownerPath,
+      callbacks: []
+    };
+    mod2.callbacks.push({
+      deps,
+      fn: callback
+    });
+    maps.hotModulesMap.set(ownerPath, mod2);
+  }
+  const hot = {
+    get data() {
+      return maps.dataMap.get(ownerPath);
+    },
+    acceptExports(_, callback) {
+      acceptDeps([ownerPath], callback && (([mod2]) => callback(mod2)));
+    },
+    accept(deps, callback) {
+      if (typeof deps === "function" || !deps) {
+        acceptDeps([ownerPath], ([mod2]) => deps && deps(mod2));
+      } else if (typeof deps === "string") {
+        acceptDeps([deps], ([mod2]) => callback && callback(mod2));
+      } else if (Array.isArray(deps)) {
+        acceptDeps(deps, callback);
+      } else {
+        throw new TypeError("invalid hot.accept() usage.");
+      }
+    },
+    dispose(cb) {
+      maps.disposeMap.set(ownerPath, cb);
+    },
+    prune(cb) {
+      maps.pruneMap.set(ownerPath, cb);
+    },
+    invalidate() {
+      notifyListeners(runner, "vite:invalidate", { path: ownerPath, message: void 0 });
+      return reload(runner, files);
+    },
+    on(event, cb) {
+      const addToMap = (map) => {
+        const existing = map.get(event) || [];
+        existing.push(cb);
+        map.set(event, existing);
+      };
+      addToMap(maps.customListenersMap);
+      addToMap(newListeners);
+    },
+    send(event, data) {
+      maps.messageBuffer.push(JSON.stringify({ type: "custom", event, data }));
+      sendMessageBuffer(runner, emitter);
+    }
+  };
+  return hot;
+}
+
+export { createHmrEmitter, createHotContext, getCache, handleMessage, reload, sendMessageBuffer, viteNodeHmrPlugin };

package/dist/{types-2dc895bd.d.ts → index-6fb787b2.d.ts}

@@ -1,4 +1,4 @@
-import { E as EncodedSourceMap } from './types.d-7442d07f.js';
+import { E as EncodedSourceMap } from './trace-mapping.d-e677e8f4.js';
 
 type HMRPayload =
   | ConnectedPayload
@@ -69,6 +69,18 @@ interface CustomEventMap {
   'vite:beforeFullReload': FullReloadPayload
   'vite:error': ErrorPayload
   'vite:invalidate': InvalidatePayload
+  'vite:ws:connect': WebSocketConnectionPayload
+  'vite:ws:disconnect': WebSocketConnectionPayload
+}
+
+interface WebSocketConnectionPayload {
+  /**
+   * @experimental
+   * We expose this instance experimentally to see potential usage.
+   * This might be removed in the future if we didn't find reasonable use cases.
+   * If you find this useful, please open an issue with details so we can discuss and make it stable API.
+   */
+  webSocket: WebSocket
 }
 
 interface InvalidatePayload {
@@ -283,4 +295,4 @@ interface DebuggerOptions {
     loadDumppedModules?: boolean;
 }
 
-export { Arrayable as A, CreateHotContextFunction as C, DepsHandlingOptions as D, FetchResult as F, HotContext as H, ModuleCacheMap as M, Nullable as N, RawSourceMap as R, StartOfSourceMap as S, ViteNodeRunnerOptions as V, Awaitable as a, FetchFunction as b, ResolveIdFunction as c, ModuleCache as d, ViteNodeResolveId as e, ViteNodeServerOptions as f, DebuggerOptions as g, CustomEventMap as h, ViteNodeRunner as i, HMRPayload as j, DEFAULT_REQUEST_STUBS as k };
+export { Arrayable as A, CustomEventMap as C, DebuggerOptions as D, FetchResult as F, HMRPayload as H, ModuleCacheMap as M, Nullable as N, RawSourceMap as R, StartOfSourceMap as S, ViteNodeServerOptions as V, ViteNodeRunner as a, HotContext as b, DepsHandlingOptions as c, ViteNodeResolveId as d, DEFAULT_REQUEST_STUBS as e, Awaitable as f, FetchFunction as g, ResolveIdFunction as h, CreateHotContextFunction as i, ModuleCache as j, ViteNodeRunnerOptions as k };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { A as Arrayable, a as Awaitable, C as CreateHotContextFunction, g as DebuggerOptions, D as DepsHandlingOptions, b as FetchFunction, F as FetchResult, H as HotContext, d as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, c as ResolveIdFunction, S as StartOfSourceMap, e as ViteNodeResolveId, V as ViteNodeRunnerOptions, f as ViteNodeServerOptions } from './types-2dc895bd.js';
-export { D as DecodedSourceMap, E as EncodedSourceMap } from './types.d-7442d07f.js';
+export { A as Arrayable, f as Awaitable, i as CreateHotContextFunction, D as DebuggerOptions, c as DepsHandlingOptions, g as FetchFunction, F as FetchResult, b as HotContext, j as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, h as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, k as ViteNodeRunnerOptions, V as ViteNodeServerOptions } from './index-6fb787b2.js';
+export { D as DecodedSourceMap, E as EncodedSourceMap, S as SourceMapInput } from './trace-mapping.d-e677e8f4.js';

package/dist/server.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var perf_hooks = require('perf_hooks');
 var fs = require('fs');
 var pathe = require('pathe');
@@ -15,11 +13,6 @@ require('node:url');
 require('module');
 require('path');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var createDebug__default = /*#__PURE__*/_interopDefaultLegacy(createDebug);
-var c__default = /*#__PURE__*/_interopDefaultLegacy(c);
-
 const ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/;
 const ESM_FOLDER_RE = /\/(es|esm)\/(.*\.js)$/;
 const defaultInline = [
@@ -126,9 +119,9 @@ class Debugger {
       this.dumpDir = pathe.resolve(root, options.dumpModules === true ? ".vite-node/dump" : options.dumpModules);
     if (this.dumpDir) {
       if (options.loadDumppedModules)
-        console.info(c__default["default"].gray(`[vite-node] [debug] load modules from ${this.dumpDir}`));
+        console.info(c.gray(`[vite-node] [debug] load modules from ${this.dumpDir}`));
       else
-        console.info(c__default["default"].gray(`[vite-node] [debug] dump modules to ${this.dumpDir}`));
+        console.info(c.gray(`[vite-node] [debug] dump modules to ${this.dumpDir}`));
     }
     this.initPromise = this.clearDump();
   }
@@ -184,7 +177,7 @@ ${result.code}`, "utf-8");
   }
 }
 
-const debugRequest = createDebug__default["default"]("vite-node:server:request");
+const debugRequest = createDebug("vite-node:server:request");
 class ViteNodeServer {
   constructor(server, options = {}) {
     this.server = server;
@@ -249,7 +242,7 @@ class ViteNodeServer {
     });
   }
   async resolveId(id, importer, transformMode) {
-    if (importer && !importer.startsWith(this.server.config.root))
+    if (importer && !importer.startsWith(utils.withTrailingSlash(this.server.config.root)))
       importer = pathe.resolve(this.server.config.root, importer);
     const mode = transformMode ?? (importer && this.getTransformMode(importer) || "ssr");
     return this.server.pluginContainer.resolveId(id, importer, { ssr: mode === "ssr" });
@@ -313,7 +306,7 @@ class ViteNodeServer {
     let result;
     const cacheDir = (_a = this.options.deps) == null ? void 0 : _a.cacheDir;
     if (cacheDir && id.includes(cacheDir)) {
-      if (!id.startsWith(this.server.config.root))
+      if (!id.startsWith(utils.withTrailingSlash(this.server.config.root)))
         id = pathe.join(this.server.config.root, id);
       const timeout = setTimeout(() => {
         throw new Error(`ViteNodeServer: ${id} not found. This is a bug, please report it.`);

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import { TransformResult, ViteDevServer } from 'vite';
-import { E as EncodedSourceMap } from './types.d-7442d07f.js';
-import { g as DebuggerOptions, D as DepsHandlingOptions, f as ViteNodeServerOptions, F as FetchResult, e as ViteNodeResolveId } from './types-2dc895bd.js';
+import { D as DebuggerOptions, c as DepsHandlingOptions, V as ViteNodeServerOptions, F as FetchResult, d as ViteNodeResolveId } from './index-6fb787b2.js';
+import { E as EncodedSourceMap } from './trace-mapping.d-e677e8f4.js';
 
 declare class Debugger {
     options: DebuggerOptions;

package/dist/server.mjs

@@ -3,7 +3,7 @@ import { existsSync, promises } from 'node:fs';
 import { join, resolve, relative, normalize } from 'pathe';
 import createDebug from 'debug';
 import { isValidNodeImport } from 'mlly';
-import { isNodeBuiltin, slash, toArray, normalizeModuleId, toFilePath } from './utils.mjs';
+import { isNodeBuiltin, slash, toArray, withTrailingSlash, normalizeModuleId, toFilePath } from './utils.mjs';
 import { KNOWN_ASSET_TYPES } from './constants.mjs';
 import c from 'picocolors';
 import { withInlineSourcemap } from './source-map.mjs';
@@ -240,7 +240,7 @@ class ViteNodeServer {
     });
   }
   async resolveId(id, importer, transformMode) {
-    if (importer && !importer.startsWith(this.server.config.root))
+    if (importer && !importer.startsWith(withTrailingSlash(this.server.config.root)))
       importer = resolve(this.server.config.root, importer);
     const mode = transformMode ?? (importer && this.getTransformMode(importer) || "ssr");
     return this.server.pluginContainer.resolveId(id, importer, { ssr: mode === "ssr" });
@@ -304,7 +304,7 @@ class ViteNodeServer {
     let result;
     const cacheDir = (_a = this.options.deps) == null ? void 0 : _a.cacheDir;
     if (cacheDir && id.includes(cacheDir)) {
-      if (!id.startsWith(this.server.config.root))
+      if (!id.startsWith(withTrailingSlash(this.server.config.root)))
         id = join(this.server.config.root, id);
       const timeout = setTimeout(() => {
         throw new Error(`ViteNodeServer: ${id} not found. This is a bug, please report it.`);

package/dist/source-map.cjs

@@ -1,15 +1,11 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var pathe = require('pathe');
+var utils = require('./utils.cjs');
 var path = require('path');
 var fs = require('fs');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+require('node:url');
+require('module');
 
 const comma = ','.charCodeAt(0);
 const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
@@ -597,8 +593,8 @@ retrieveFileHandlers.push((path2) => {
     return fileContentsCache[path2];
   let contents = "";
   try {
-    if (fs__default["default"].existsSync(path2))
-      contents = fs__default["default"].readFileSync(path2, "utf8");
+    if (fs.existsSync(path2))
+      contents = fs.readFileSync(path2, "utf8");
   } catch (er) {
   }
   return fileContentsCache[path2] = contents;
@@ -606,15 +602,15 @@ retrieveFileHandlers.push((path2) => {
 function supportRelativeURL(file, url) {
   if (!file)
     return url;
-  const dir = path__default["default"].dirname(file);
+  const dir = path.dirname(file);
   const match = /^\w+:\/\/[^\/]*/.exec(dir);
   let protocol = match ? match[0] : "";
   const startPath = dir.slice(protocol.length);
   if (protocol && /^\/\w\:/.test(startPath)) {
     protocol += "/";
-    return protocol + path__default["default"].resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
+    return protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
   }
-  return protocol + path__default["default"].resolve(dir.slice(protocol.length), url);
+  return protocol + path.resolve(dir.slice(protocol.length), url);
 }
 function retrieveSourceMapURL(source) {
   const fileData = retrieveFile(source);
@@ -871,15 +867,17 @@ function withInlineSourcemap(result, options) {
   let code = result.code;
   if (!map || code.includes(VITE_NODE_SOURCEMAPPING_SOURCE))
     return result;
-  map.sources = (_a = map.sources) == null ? void 0 : _a.map((source) => {
-    if (!source)
+  if ("sources" in map) {
+    map.sources = (_a = map.sources) == null ? void 0 : _a.map((source) => {
+      if (!source)
+        return source;
+      if (pathe.isAbsolute(source)) {
+        const actualPath = !source.startsWith(utils.withTrailingSlash(options.root)) && source.startsWith("/") ? pathe.resolve(options.root, source.slice(1)) : source;
+        return pathe.relative(pathe.dirname(options.filepath), actualPath);
+      }
       return source;
-    if (pathe.isAbsolute(source)) {
-      const actualPath = !source.startsWith(options.root) && source.startsWith("/") ? pathe.resolve(options.root, source.slice(1)) : source;
-      return pathe.relative(pathe.dirname(options.filepath), actualPath);
-    }
-    return source;
-  });
+    });
+  }
   const OTHER_SOURCE_MAP_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`, "gm");
   while (OTHER_SOURCE_MAP_REGEXP.test(code))
     code = code.replace(OTHER_SOURCE_MAP_REGEXP, "");

package/dist/source-map.d.ts

@@ -1,5 +1,5 @@
 import { TransformResult } from 'vite';
-import { E as EncodedSourceMap } from './types.d-7442d07f.js';
+import { E as EncodedSourceMap } from './trace-mapping.d-e677e8f4.js';
 
 interface InstallSourceMapSupportOptions {
     getSourceMap: (source: string) => EncodedSourceMap | null | undefined;

package/dist/source-map.mjs

@@ -1,6 +1,9 @@
 import { isAbsolute, resolve as resolve$2, relative, dirname } from 'pathe';
+import { withTrailingSlash } from './utils.mjs';
 import path from 'node:path';
 import fs from 'node:fs';
+import 'node:url';
+import 'node:module';
 
 const comma = ','.charCodeAt(0);
 const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
@@ -862,15 +865,17 @@ function withInlineSourcemap(result, options) {
   let code = result.code;
   if (!map || code.includes(VITE_NODE_SOURCEMAPPING_SOURCE))
     return result;
-  map.sources = (_a = map.sources) == null ? void 0 : _a.map((source) => {
-    if (!source)
+  if ("sources" in map) {
+    map.sources = (_a = map.sources) == null ? void 0 : _a.map((source) => {
+      if (!source)
+        return source;
+      if (isAbsolute(source)) {
+        const actualPath = !source.startsWith(withTrailingSlash(options.root)) && source.startsWith("/") ? resolve$2(options.root, source.slice(1)) : source;
+        return relative(dirname(options.filepath), actualPath);
+      }
       return source;
-    if (isAbsolute(source)) {
-      const actualPath = !source.startsWith(options.root) && source.startsWith("/") ? resolve$2(options.root, source.slice(1)) : source;
-      return relative(dirname(options.filepath), actualPath);
-    }
-    return source;
-  });
+    });
+  }
   const OTHER_SOURCE_MAP_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`, "gm");
   while (OTHER_SOURCE_MAP_REGEXP.test(code))
     code = code.replace(OTHER_SOURCE_MAP_REGEXP, "");

package/dist/trace-mapping.d-e677e8f4.d.ts

@@ -0,0 +1,54 @@
+declare type GeneratedColumn = number;
+declare type SourcesIndex = number;
+declare type SourceLine = number;
+declare type SourceColumn = number;
+declare type NamesIndex = number;
+declare type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+
+interface SourceMapV3 {
+    file?: string | null;
+    names: string[];
+    sourceRoot?: string;
+    sources: (string | null)[];
+    sourcesContent?: (string | null)[];
+    version: 3;
+}
+interface EncodedSourceMap extends SourceMapV3 {
+    mappings: string;
+}
+interface DecodedSourceMap extends SourceMapV3 {
+    mappings: SourceMapSegment[][];
+}
+declare type SourceMapInput = string | Ro<EncodedSourceMap> | Ro<DecodedSourceMap> | TraceMap;
+declare abstract class SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    resolvedSources: SourceMapV3['sources'];
+}
+declare type Ro<T> = T extends Array<infer V> ? V[] | Readonly<V[]> | RoArray<V> | Readonly<RoArray<V>> : T extends object ? T | Readonly<T> | RoObject<T> | Readonly<RoObject<T>> : T;
+declare type RoArray<T> = Ro<T>[];
+declare type RoObject<T> = {
+    [K in keyof T]: T[K] | Ro<T[K]>;
+};
+
+declare class TraceMap implements SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    resolvedSources: string[];
+    private _encoded;
+    private _decoded;
+    private _decodedMemo;
+    private _bySources;
+    private _bySourceMemos;
+    constructor(map: SourceMapInput, mapUrl?: string | null);
+}
+
+export { DecodedSourceMap as D, EncodedSourceMap as E, SourceMapInput as S };

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-export { A as Arrayable, a as Awaitable, C as CreateHotContextFunction, g as DebuggerOptions, D as DepsHandlingOptions, b as FetchFunction, F as FetchResult, H as HotContext, d as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, c as ResolveIdFunction, S as StartOfSourceMap, e as ViteNodeResolveId, V as ViteNodeRunnerOptions, f as ViteNodeServerOptions } from './types-2dc895bd.js';
-export { D as DecodedSourceMap, E as EncodedSourceMap } from './types.d-7442d07f.js';
+export { A as Arrayable, f as Awaitable, i as CreateHotContextFunction, D as DebuggerOptions, c as DepsHandlingOptions, g as FetchFunction, F as FetchResult, b as HotContext, j as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, h as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, k as ViteNodeRunnerOptions, V as ViteNodeServerOptions } from './index-6fb787b2.js';
+export { D as DecodedSourceMap, E as EncodedSourceMap, S as SourceMapInput } from './trace-mapping.d-e677e8f4.js';

package/dist/utils.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var node_url = require('node:url');
 var module$1 = require('module');
 var fs = require('fs');
@@ -17,7 +15,7 @@ function slash(str) {
 }
 const VALID_ID_PREFIX = "/@id/";
 function normalizeRequestId(id, base) {
-  if (base && id.startsWith(base))
+  if (base && id.startsWith(withTrailingSlash(base)))
     id = `/${id.slice(base.length)}`;
   if (driveRegexp && !(driveRegexp == null ? void 0 : driveRegexp.test(id)) && (driveOppositeRegext == null ? void 0 : driveOppositeRegext.test(id)))
     id = id.replace(driveOppositeRegext, `${drive}$1`);
@@ -67,11 +65,11 @@ function toFilePath(id, root) {
   let { absolute, exists } = (() => {
     if (id.startsWith("/@fs/"))
       return { absolute: id.slice(4), exists: true };
-    if (!id.startsWith(root) && id.startsWith("/")) {
+    if (!id.startsWith(withTrailingSlash(root)) && id.startsWith("/")) {
       const resolved = pathe.resolve(root, id.slice(1));
       if (fs.existsSync(cleanUrl(resolved)))
         return { absolute: resolved, exists: true };
-    } else if (id.startsWith(root) && fs.existsSync(cleanUrl(id))) {
+    } else if (id.startsWith(withTrailingSlash(root)) && fs.existsSync(cleanUrl(id))) {
       return { absolute: id, exists: true };
     }
     return { absolute: id, exists: false };
@@ -122,6 +120,11 @@ function traverseBetweenDirs(longerDir, shorterDir, cb) {
     longerDir = pathe.dirname(longerDir);
   }
 }
+function withTrailingSlash(path) {
+  if (path[path.length - 1] !== "/")
+    return `${path}/`;
+  return path;
+}
 function createImportMetaEnvProxy() {
   const booleanKeys = [
     "DEV",
@@ -164,3 +167,4 @@ exports.setCacheData = setCacheData;
 exports.slash = slash;
 exports.toArray = toArray;
 exports.toFilePath = toFilePath;
+exports.withTrailingSlash = withTrailingSlash;

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { N as Nullable, A as Arrayable } from './types-2dc895bd.js';
-import './types.d-7442d07f.js';
+import { N as Nullable, A as Arrayable } from './index-6fb787b2.js';
+import './trace-mapping.d-e677e8f4.js';
 
 declare const isWindows: boolean;
 declare function slash(str: string): string;
@@ -24,6 +24,7 @@ declare function isNodeBuiltin(id: string): boolean;
 declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
 declare function getCachedData<T>(cache: Map<string, T>, basedir: string, originalBasedir: string): NonNullable<T> | undefined;
 declare function setCacheData<T>(cache: Map<string, T>, data: T, basedir: string, originalBasedir: string): void;
+declare function withTrailingSlash(path: string): string;
 declare function createImportMetaEnvProxy(): NodeJS.ProcessEnv;
 
-export { VALID_ID_PREFIX, cleanUrl, createImportMetaEnvProxy, getCachedData, hashRE, isInternalRequest, isNodeBuiltin, isPrimitive, isWindows, normalizeModuleId, normalizeRequestId, queryRE, setCacheData, slash, toArray, toFilePath };
+export { VALID_ID_PREFIX, cleanUrl, createImportMetaEnvProxy, getCachedData, hashRE, isInternalRequest, isNodeBuiltin, isPrimitive, isWindows, normalizeModuleId, normalizeRequestId, queryRE, setCacheData, slash, toArray, toFilePath, withTrailingSlash };

package/dist/utils.mjs

@@ -13,7 +13,7 @@ function slash(str) {
 }
 const VALID_ID_PREFIX = "/@id/";
 function normalizeRequestId(id, base) {
-  if (base && id.startsWith(base))
+  if (base && id.startsWith(withTrailingSlash(base)))
     id = `/${id.slice(base.length)}`;
   if (driveRegexp && !(driveRegexp == null ? void 0 : driveRegexp.test(id)) && (driveOppositeRegext == null ? void 0 : driveOppositeRegext.test(id)))
     id = id.replace(driveOppositeRegext, `${drive}$1`);
@@ -63,11 +63,11 @@ function toFilePath(id, root) {
   let { absolute, exists } = (() => {
     if (id.startsWith("/@fs/"))
       return { absolute: id.slice(4), exists: true };
-    if (!id.startsWith(root) && id.startsWith("/")) {
+    if (!id.startsWith(withTrailingSlash(root)) && id.startsWith("/")) {
       const resolved = resolve(root, id.slice(1));
       if (existsSync(cleanUrl(resolved)))
         return { absolute: resolved, exists: true };
-    } else if (id.startsWith(root) && existsSync(cleanUrl(id))) {
+    } else if (id.startsWith(withTrailingSlash(root)) && existsSync(cleanUrl(id))) {
       return { absolute: id, exists: true };
     }
     return { absolute: id, exists: false };
@@ -118,6 +118,11 @@ function traverseBetweenDirs(longerDir, shorterDir, cb) {
     longerDir = dirname(longerDir);
   }
 }
+function withTrailingSlash(path) {
+  if (path[path.length - 1] !== "/")
+    return `${path}/`;
+  return path;
+}
 function createImportMetaEnvProxy() {
   const booleanKeys = [
     "DEV",
@@ -144,4 +149,4 @@ function createImportMetaEnvProxy() {
   });
 }
 
-export { VALID_ID_PREFIX, cleanUrl, createImportMetaEnvProxy, getCachedData, hashRE, isInternalRequest, isNodeBuiltin, isPrimitive, isWindows, normalizeModuleId, normalizeRequestId, queryRE, setCacheData, slash, toArray, toFilePath };
+export { VALID_ID_PREFIX, cleanUrl, createImportMetaEnvProxy, getCachedData, hashRE, isInternalRequest, isNodeBuiltin, isPrimitive, isWindows, normalizeModuleId, normalizeRequestId, queryRE, setCacheData, slash, toArray, toFilePath, withTrailingSlash };