vite-node 4.0.0-beta.8 → 5.0.0-beta.2

package/dist/{source-map.mjs → source-map.js}

@@ -1,110 +1,109 @@
+import { Buffer } from 'node:buffer';
 import { isAbsolute, resolve as resolve$1, relative, dirname } from 'pathe';
 import fs from 'node:fs';
 import path from 'node:path';
-import { withTrailingSlash } from './utils.mjs';
+import process from 'node:process';
+import { withTrailingSlash } from './utils.js';
 import 'node:module';
 import 'node:url';
 
-const comma = ','.charCodeAt(0);
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar = new Uint8Array(64); // 64 possible chars.
-const charToInt = new Uint8Array(128); // z is 122 in ASCII
+// src/vlq.ts
+var comma = ",".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
 for (let i = 0; i < chars.length; i++) {
-    const c = chars.charCodeAt(i);
-    intToChar[i] = c;
-    charToInt[c] = i;
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
 }
 function decodeInteger(reader, relative) {
-    let value = 0;
-    let shift = 0;
-    let integer = 0;
-    do {
-        const c = reader.next();
-        integer = charToInt[c];
-        value |= (integer & 31) << shift;
-        shift += 5;
-    } while (integer & 32);
-    const shouldNegate = value & 1;
-    value >>>= 1;
-    if (shouldNegate) {
-        value = -2147483648 | -value;
-    }
-    return relative + value;
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
 }
 function hasMoreVlq(reader, max) {
-    if (reader.pos >= max)
-        return false;
-    return reader.peek() !== comma;
-}
-class StringReader {
-    constructor(buffer) {
-        this.pos = 0;
-        this.buffer = buffer;
-    }
-    next() {
-        return this.buffer.charCodeAt(this.pos++);
-    }
-    peek() {
-        return this.buffer.charCodeAt(this.pos);
-    }
-    indexOf(char) {
-        const { buffer, pos } = this;
-        const idx = buffer.indexOf(char, pos);
-        return idx === -1 ? buffer.length : idx;
-    }
+  if (reader.pos >= max) return false;
+  return reader.peek() !== comma;
 }
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
 
+// src/sourcemap-codec.ts
 function decode(mappings) {
-    const { length } = mappings;
-    const reader = new StringReader(mappings);
-    const decoded = [];
-    let genColumn = 0;
-    let sourcesIndex = 0;
-    let sourceLine = 0;
-    let sourceColumn = 0;
-    let namesIndex = 0;
-    do {
-        const semi = reader.indexOf(';');
-        const line = [];
-        let sorted = true;
-        let lastCol = 0;
-        genColumn = 0;
-        while (reader.pos < semi) {
-            let seg;
-            genColumn = decodeInteger(reader, genColumn);
-            if (genColumn < lastCol)
-                sorted = false;
-            lastCol = genColumn;
-            if (hasMoreVlq(reader, semi)) {
-                sourcesIndex = decodeInteger(reader, sourcesIndex);
-                sourceLine = decodeInteger(reader, sourceLine);
-                sourceColumn = decodeInteger(reader, sourceColumn);
-                if (hasMoreVlq(reader, semi)) {
-                    namesIndex = decodeInteger(reader, namesIndex);
-                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
-                }
-                else {
-                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
-                }
-            }
-            else {
-                seg = [genColumn];
-            }
-            line.push(seg);
-            reader.pos++;
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol) sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
         }
-        if (!sorted)
-            sort(line);
-        decoded.push(line);
-        reader.pos = semi + 1;
-    } while (reader.pos <= length);
-    return decoded;
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted) sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
 }
 function sort(line) {
-    line.sort(sortComparator$1);
+  line.sort(sortComparator$1);
 }
 function sortComparator$1(a, b) {
-    return a[0] - b[0];
+  return a[0] - b[0];
 }
 
 // Matches the scheme of a URL, eg "http://"
@@ -130,16 +129,6 @@ const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#
  * 4. Hash, including "#", optional.
  */
 const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
-var UrlType;
-(function (UrlType) {
-    UrlType[UrlType["Empty"] = 1] = "Empty";
-    UrlType[UrlType["Hash"] = 2] = "Hash";
-    UrlType[UrlType["Query"] = 3] = "Query";
-    UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
-    UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
-    UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
-    UrlType[UrlType["Absolute"] = 7] = "Absolute";
-})(UrlType || (UrlType = {}));
 function isAbsoluteUrl(input) {
     return schemeRegex.test(input);
 }
@@ -173,21 +162,21 @@ function makeUrl(scheme, user, host, port, path, query, hash) {
         path,
         query,
         hash,
-        type: UrlType.Absolute,
+        type: 7 /* Absolute */,
     };
 }
 function parseUrl(input) {
     if (isSchemeRelativeUrl(input)) {
         const url = parseAbsoluteUrl('http:' + input);
         url.scheme = '';
-        url.type = UrlType.SchemeRelative;
+        url.type = 6 /* SchemeRelative */;
         return url;
     }
     if (isAbsolutePath(input)) {
         const url = parseAbsoluteUrl('http://foo.com' + input);
         url.scheme = '';
         url.host = '';
-        url.type = UrlType.AbsolutePath;
+        url.type = 5 /* AbsolutePath */;
         return url;
     }
     if (isFileUrl(input))
@@ -199,11 +188,11 @@ function parseUrl(input) {
     url.host = '';
     url.type = input
         ? input.startsWith('?')
-            ? UrlType.Query
+            ? 3 /* Query */
             : input.startsWith('#')
-                ? UrlType.Hash
-                : UrlType.RelativePath
-        : UrlType.Empty;
+                ? 2 /* Hash */
+                : 4 /* RelativePath */
+        : 1 /* Empty */;
     return url;
 }
 function stripPathFilename(path) {
@@ -231,7 +220,7 @@ function mergePaths(url, base) {
  * "foo/.". We need to normalize to a standard representation.
  */
 function normalizePath(url, type) {
-    const rel = type <= UrlType.RelativePath;
+    const rel = type <= 4 /* RelativePath */;
     const pieces = url.path.split('/');
     // We need to preserve the first piece always, so that we output a leading slash. The item at
     // pieces[0] is an empty string.
@@ -292,27 +281,27 @@ function resolve(input, base) {
         return '';
     const url = parseUrl(input);
     let inputType = url.type;
-    if (base && inputType !== UrlType.Absolute) {
+    if (base && inputType !== 7 /* Absolute */) {
         const baseUrl = parseUrl(base);
         const baseType = baseUrl.type;
         switch (inputType) {
-            case UrlType.Empty:
+            case 1 /* Empty */:
                 url.hash = baseUrl.hash;
             // fall through
-            case UrlType.Hash:
+            case 2 /* Hash */:
                 url.query = baseUrl.query;
             // fall through
-            case UrlType.Query:
-            case UrlType.RelativePath:
+            case 3 /* Query */:
+            case 4 /* RelativePath */:
                 mergePaths(url, baseUrl);
             // fall through
-            case UrlType.AbsolutePath:
+            case 5 /* AbsolutePath */:
                 // The host, user, and port are joined, you can't copy one without the others.
                 url.user = baseUrl.user;
                 url.host = baseUrl.host;
                 url.port = baseUrl.port;
             // fall through
-            case UrlType.SchemeRelative:
+            case 6 /* SchemeRelative */:
                 // The input doesn't have a schema at least, so we need to copy at least that over.
                 url.scheme = baseUrl.scheme;
         }
@@ -324,10 +313,10 @@ function resolve(input, base) {
     switch (inputType) {
         // This is impossible, because of the empty checks at the start of the function.
         // case UrlType.Empty:
-        case UrlType.Hash:
-        case UrlType.Query:
+        case 2 /* Hash */:
+        case 3 /* Query */:
             return queryHash;
-        case UrlType.RelativePath: {
+        case 4 /* RelativePath */: {
             // The first char is always a "/", and we need it to be relative.
             const path = url.path.slice(1);
             if (!path)
@@ -340,7 +329,7 @@ function resolve(input, base) {
             }
             return path + queryHash;
         }
-        case UrlType.AbsolutePath:
+        case 5 /* AbsolutePath */:
             return url.path + queryHash;
         default:
             return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
@@ -550,11 +539,17 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
 // Only install once if called multiple times
 let errorFormatterInstalled = false;
 // Maps a file path to a string containing the file contents
-const fileContentsCache = {}, sourceMapCache = {}, reSourceMap = /^data:application\/json[^,]+base64,/;
+const fileContentsCache = {};
+// Maps a file path to a source map for that file
+const sourceMapCache = {};
+// Regex for detecting source maps
+const reSourceMap = /^data:application\/json[^,]+base64,/;
 // Priority list of retrieve handlers
-let retrieveFileHandlers = [], retrieveMapHandlers = [];
+let retrieveFileHandlers = [];
+let retrieveMapHandlers = [];
 function globalProcessVersion() {
-	return typeof process === "object" && process !== null ? process.version : "";
+	if (typeof process === "object" && process !== null) return process.version;
+	else return "";
 }
 function handlerExec(list) {
 	return function(arg) {
@@ -567,7 +562,9 @@ function handlerExec(list) {
 }
 let retrieveFile = handlerExec(retrieveFileHandlers);
 retrieveFileHandlers.push((path) => {
-	if (path = path.trim(), path.startsWith("file:"))
+	// Trim the path to make sure there is no extra whitespace.
+	path = path.trim();
+	if (path.startsWith("file:"))
  // existsSync/readFileSync can't handle file protocol, but once stripped, it works
 	path = path.replace(/file:\/\/\/(\w:)?/, (protocol, drive) => {
 		return drive ? "" : "/";
@@ -582,10 +579,16 @@ retrieveFileHandlers.push((path) => {
 // Support URLs relative to a directory, but be careful about a protocol prefix
 function supportRelativeURL(file, url) {
 	if (!file) return url;
-	const dir = path.dirname(file), match = /^\w+:\/\/[^/]*/.exec(dir);
+	const dir = path.dirname(file);
+	const match = /^\w+:\/\/[^/]*/.exec(dir);
 	let protocol = match ? match[0] : "";
 	const startPath = dir.slice(protocol.length);
-	return protocol && /^\/\w:/.test(startPath) ? (protocol += "/", protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/")) : protocol + path.resolve(dir.slice(protocol.length), url);
+	if (protocol && /^\/\w:/.test(startPath)) {
+		// handle file:///C:/ paths
+		protocol += "/";
+		return protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
+	}
+	return protocol + path.resolve(dir.slice(protocol.length), url);
 }
 function retrieveSourceMapURL(source) {
 	// Get the URL of the source map
@@ -597,7 +600,8 @@ function retrieveSourceMapURL(source) {
 	let lastMatch, match;
 	// eslint-disable-next-line no-cond-assign
 	while (match = re.exec(fileData)) lastMatch = match;
-	return lastMatch ? lastMatch[1] : null;
+	if (!lastMatch) return null;
+	return lastMatch[1];
 }
 // Can be overridden by the retrieveSourceMap option to install. Takes a
 // generated source filename; returns a {map, optional url} object, or null if
@@ -613,12 +617,18 @@ retrieveMapHandlers.push((source) => {
 	if (reSourceMap.test(sourceMappingURL)) {
 		// Support source map URL as a data url
 		const rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1);
-		sourceMapData = Buffer.from(rawData, "base64").toString(), sourceMappingURL = source;
-	} else sourceMappingURL = supportRelativeURL(source, sourceMappingURL), sourceMapData = retrieveFile(sourceMappingURL);
-	return sourceMapData ? {
+		sourceMapData = Buffer.from(rawData, "base64").toString();
+		sourceMappingURL = source;
+	} else {
+		// Support source map URLs relative to the source URL
+		sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
+		sourceMapData = retrieveFile(sourceMappingURL);
+	}
+	if (!sourceMapData) return null;
+	return {
 		url: sourceMappingURL,
 		map: sourceMapData
-	} : null;
+	};
 });
 // interface Position {
 //   source: string
@@ -630,15 +640,17 @@ function mapSourcePosition(position) {
 	let sourceMap = sourceMapCache[position.source];
 	if (!sourceMap) {
 		// Call the (overridable) retrieveSourceMap function to get the source map.
-		const urlAndMap = retrieveSourceMap(position.source), map = urlAndMap && urlAndMap.map;
+		const urlAndMap = retrieveSourceMap(position.source);
+		const map = urlAndMap && urlAndMap.map;
 		if (map && !(typeof map === "object" && "mappings" in map && map.mappings === "")) {
 			var _sourceMap$map;
-			// Load all sources stored inline with the source map into the file cache
-			// to pretend like they are already loaded. They may not exist on disk.
-			if (sourceMap = sourceMapCache[position.source] = {
+			sourceMap = sourceMapCache[position.source] = {
 				url: urlAndMap.url,
 				map: new TraceMap(map)
-			}, (_sourceMap$map = sourceMap.map) === null || _sourceMap$map === void 0 ? void 0 : _sourceMap$map.sourcesContent) sourceMap.map.sources.forEach((source, i) => {
+			};
+			// Load all sources stored inline with the source map into the file cache
+			// to pretend like they are already loaded. They may not exist on disk.
+			if ((_sourceMap$map = sourceMap.map) === null || _sourceMap$map === void 0 ? void 0 : _sourceMap$map.sourcesContent) sourceMap.map.sources.forEach((source, i) => {
 				var _sourceMap$map2;
 				const contents = (_sourceMap$map2 = sourceMap.map) === null || _sourceMap$map2 === void 0 || (_sourceMap$map2 = _sourceMap$map2.sourcesContent) === null || _sourceMap$map2 === void 0 ? void 0 : _sourceMap$map2[i];
 				if (contents && source && sourceMap.url) {
@@ -659,7 +671,10 @@ function mapSourcePosition(position) {
 		// the stack trace to print the path and line for the compiled file. It is
 		// better to give a precise location in the compiled file than a vague
 		// location in the original file.
-		if (originalPosition.source !== null) return originalPosition.source = supportRelativeURL(sourceMap.url, originalPosition.source), originalPosition;
+		if (originalPosition.source !== null) {
+			originalPosition.source = supportRelativeURL(sourceMap.url, originalPosition.source);
+			return originalPosition;
+		}
 	}
 	return position;
 }
@@ -677,8 +692,11 @@ function mapEvalOrigin(origin) {
 		});
 		return `eval at ${match[1]} (${position.source}:${position.line}:${position.column + 1})`;
 	}
+	// Parse nested eval() calls using recursion
+	match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
+	if (match) return `eval at ${match[1]} (${mapEvalOrigin(match[2])})`;
 	// Make sure we still return useful information if we didn't find anything
-	return match = /^eval at ([^(]+) \((.+)\)$/.exec(origin), match ? `eval at ${match[1]} (${mapEvalOrigin(match[2])})` : origin;
+	return origin;
 }
 // This is copied almost verbatim from the V8 source code at
 // https://code.google.com/p/v8/source/browse/trunk/src/messages.js. The
@@ -687,10 +705,15 @@ function mapEvalOrigin(origin) {
 // did something to the prototype chain and broke the shim. The only fix I
 // could find was copy/paste.
 function CallSiteToString() {
-	let fileName, fileLocation = "";
+	let fileName;
+	let fileLocation = "";
 	if (this.isNative()) fileLocation = "native";
 	else {
-		if (fileName = this.getScriptNameOrSourceURL(), !fileName && this.isEval()) fileLocation = this.getEvalOrigin(), fileLocation += ", ";
+		fileName = this.getScriptNameOrSourceURL();
+		if (!fileName && this.isEval()) {
+			fileLocation = this.getEvalOrigin();
+			fileLocation += ", ";
+		}
 		if (fileName) fileLocation += fileName;
 		else
  // Source code does not originate from a file and is not native, but we
@@ -707,32 +730,38 @@ function CallSiteToString() {
 	let line = "";
 	const functionName = this.getFunctionName();
 	let addSuffix = true;
-	const isConstructor = this.isConstructor(), isMethodCall = !(this.isToplevel() || isConstructor);
-	if (isMethodCall) {
+	const isConstructor = this.isConstructor();
+	if (!(this.isToplevel() || isConstructor)) {
 		let typeName = this.getTypeName();
 		// Fixes shim to be backward compatible with Node v0 to v4
 		if (typeName === "[object Object]") typeName = "null";
 		const methodName = this.getMethodName();
 		if (functionName) {
 			if (typeName && functionName.indexOf(typeName) !== 0) line += `${typeName}.`;
-			if (line += functionName, methodName && functionName.indexOf(`.${methodName}`) !== functionName.length - methodName.length - 1) line += ` [as ${methodName}]`;
+			line += functionName;
+			if (methodName && functionName.indexOf(`.${methodName}`) !== functionName.length - methodName.length - 1) line += ` [as ${methodName}]`;
 		} else line += `${typeName}.${methodName || "<anonymous>"}`;
 	} else if (isConstructor) line += `new ${functionName || "<anonymous>"}`;
 	else if (functionName) line += functionName;
-	else line += fileLocation, addSuffix = false;
+	else {
+		line += fileLocation;
+		addSuffix = false;
+	}
 	if (addSuffix) line += ` (${fileLocation})`;
 	return line;
 }
 function cloneCallSite(frame) {
 	const object = {};
-	return Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach((name) => {
+	Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach((name) => {
 		const key = name;
 		// @ts-expect-error difficult to type
 		object[key] = /^(?:is|get)/.test(name) ? function() {
 			// eslint-disable-next-line no-useless-call
 			return frame[key].call(frame);
 		} : frame[key];
-	}), object.toString = CallSiteToString, object;
+	});
+	object.toString = CallSiteToString;
+	return object;
 }
 function wrapCallSite(frame, state) {
 	// provides interface backward compatibility
@@ -740,7 +769,10 @@ function wrapCallSite(frame, state) {
 		nextPosition: null,
 		curPosition: null
 	};
-	if (frame.isNative()) return state.curPosition = null, frame;
+	if (frame.isNative()) {
+		state.curPosition = null;
+		return frame;
+	}
 	// Most call sites will return the source file from getFileName(), but code
 	// passed to eval() ending in "//# sourceURL=..." will return the source file
 	// from getScriptNameOrSourceURL() instead
@@ -748,12 +780,7 @@ function wrapCallSite(frame, state) {
 	if (source) {
 		const line = frame.getLineNumber();
 		let column = frame.getColumnNumber() - 1;
-		// Fix position in Node where some (internal) code is prepended.
-		// See https://github.com/evanw/node-source-map-support/issues/36
-		// Header removed in node at ^10.16 || >=11.11.0
-		// v11 is not an LTS candidate, we can just test the one version with it.
-		// Test node versions for: 10.16-19, 10.20+, 12-19, 20-99, 100+, or 11.11
-		const noHeader = /^v(?:10\.1[6-9]|10\.[2-9]\d|10\.\d{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/, headerLength = noHeader.test(globalProcessVersion()) ? 0 : 62;
+		const headerLength = /^v(?:10\.1[6-9]|10\.[2-9]\d|10\.\d{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/.test(globalProcessVersion()) ? 0 : 62;
 		if (line === 1 && column > headerLength && !frame.isEval()) column -= headerLength;
 		const position = mapSourcePosition({
 			name: null,
@@ -761,42 +788,63 @@ function wrapCallSite(frame, state) {
 			line,
 			column
 		});
-		state.curPosition = position, frame = cloneCallSite(frame);
+		state.curPosition = position;
+		frame = cloneCallSite(frame);
 		const originalFunctionName = frame.getFunctionName;
-		return frame.getFunctionName = function() {
-			return state.nextPosition == null ? originalFunctionName() : state.nextPosition.name || originalFunctionName();
-		}, frame.getFileName = function() {
+		frame.getFunctionName = function() {
+			if (state.nextPosition == null) return originalFunctionName();
+			return state.nextPosition.name || originalFunctionName();
+		};
+		frame.getFileName = function() {
 			return position.source ?? null;
-		}, frame.getLineNumber = function() {
+		};
+		frame.getLineNumber = function() {
 			return position.line;
-		}, frame.getColumnNumber = function() {
+		};
+		frame.getColumnNumber = function() {
 			return position.column + 1;
-		}, frame.getScriptNameOrSourceURL = function() {
+		};
+		frame.getScriptNameOrSourceURL = function() {
 			return position.source;
-		}, frame;
+		};
+		return frame;
 	}
 	// Code called using eval() needs special handling
 	let origin = frame.isEval() && frame.getEvalOrigin();
+	if (origin) {
+		origin = mapEvalOrigin(origin);
+		frame = cloneCallSite(frame);
+		frame.getEvalOrigin = function() {
+			return origin || void 0;
+		};
+		return frame;
+	}
 	// If we get here then we were unable to change the source position
-	return origin ? (origin = mapEvalOrigin(origin), frame = cloneCallSite(frame), frame.getEvalOrigin = function() {
-		return origin || void 0;
-	}, frame) : frame;
+	return frame;
 }
 // This function is part of the V8 stack trace API, for more info see:
 // https://v8.dev/docs/stack-trace-api
 function prepareStackTrace(error, stack) {
-	const name = error.name || "Error", message = error.message || "", errorString = `${name}: ${message}`, state = {
+	const errorString = `${error.name || "Error"}: ${error.message || ""}`;
+	const state = {
 		nextPosition: null,
 		curPosition: null
-	}, processedStack = [];
-	for (let i = stack.length - 1; i >= 0; i--) processedStack.push(`\n    at ${wrapCallSite(stack[i], state)}`), state.nextPosition = state.curPosition;
-	return state.curPosition = state.nextPosition = null, errorString + processedStack.reverse().join("");
+	};
+	const processedStack = [];
+	for (let i = stack.length - 1; i >= 0; i--) {
+		processedStack.push(`\n    at ${wrapCallSite(stack[i], state)}`);
+		state.nextPosition = state.curPosition;
+	}
+	state.curPosition = state.nextPosition = null;
+	return errorString + processedStack.reverse().join("");
 }
-retrieveFileHandlers.slice(0); retrieveMapHandlers.slice(0);
+retrieveFileHandlers.slice(0);
+retrieveMapHandlers.slice(0);
 function install(options) {
+	options = options || {};
 	// Allow sources to be found by methods other than reading the files
 	// directly from disk.
-	if (options = options || {}, options.retrieveFile) {
+	if (options.retrieveFile) {
 		if (options.overrideRetrieveFile) retrieveFileHandlers.length = 0;
 		retrieveFileHandlers.unshift(options.retrieveFile);
 	}
@@ -807,12 +855,16 @@ function install(options) {
 		retrieveMapHandlers.unshift(options.retrieveSourceMap);
 	}
 	// Install the error reformatter
-	if (!errorFormatterInstalled) errorFormatterInstalled = true, Error.prepareStackTrace = prepareStackTrace;
+	if (!errorFormatterInstalled) {
+		errorFormatterInstalled = true;
+		Error.prepareStackTrace = prepareStackTrace;
+	}
 }
 
 let SOURCEMAPPING_URL = "sourceMa";
 SOURCEMAPPING_URL += "ppingURL";
-const VITE_NODE_SOURCEMAPPING_SOURCE = "//# sourceMappingSource=vite-node", VITE_NODE_SOURCEMAPPING_URL = `${SOURCEMAPPING_URL}=data:application/json;charset=utf-8`;
+const VITE_NODE_SOURCEMAPPING_SOURCE = "//# sourceMappingSource=vite-node";
+const VITE_NODE_SOURCEMAPPING_URL = `${SOURCEMAPPING_URL}=data:application/json;charset=utf-8`;
 function withInlineSourcemap(result, options) {
 	const map = result.map;
 	let code = result.code;
@@ -841,22 +893,26 @@ function withInlineSourcemap(result, options) {
 	// so we don't need to add this mapping anymore.
 	if (!options.noFirstLineMapping && map.mappings.startsWith(";")) map.mappings = `AAAA,CAAA${map.mappings}`;
 	const sourceMap = Buffer.from(JSON.stringify(map), "utf-8").toString("base64");
-	return result.code = `${code.trimEnd()}\n\n${VITE_NODE_SOURCEMAPPING_SOURCE}\n//# ${VITE_NODE_SOURCEMAPPING_URL};base64,${sourceMap}\n`, result;
+	result.code = `${code.trimEnd()}\n\n${VITE_NODE_SOURCEMAPPING_SOURCE}\n//# ${VITE_NODE_SOURCEMAPPING_URL};base64,${sourceMap}\n`;
+	return result;
 }
 function extractSourceMap(code) {
 	const regexp = new RegExp(`//# ${VITE_NODE_SOURCEMAPPING_URL};base64,(.+)`, "gm");
 	let lastMatch, match;
 	// eslint-disable-next-line no-cond-assign
 	while (match = regexp.exec(code)) lastMatch = match;
-	return lastMatch ? JSON.parse(Buffer.from(lastMatch[1], "base64").toString("utf-8")) : null;
+	// pick only the last source map keeping user strings that look like maps
+	if (lastMatch) return JSON.parse(Buffer.from(lastMatch[1], "base64").toString("utf-8"));
+	return null;
 }
 function installSourcemapsSupport(options) {
 	install({ retrieveSourceMap(source) {
 		const map = options.getSourceMap(source);
-		return map ? {
+		if (map) return {
 			url: source,
 			map
-		} : null;
+		};
+		return null;
 	} });
 }