vite-node 3.2.4 → 4.0.0-beta.10

package/dist/source-map.cjs

@@ -289,7 +289,7 @@ function normalizePath(url, type) {
 /**
  * Attempts to resolve `input` URL/path relative to `base`.
  */
-function resolve$1(input, base) {
+function resolve(input, base) {
     if (!input && !base)
         return '';
     const url = parseUrl(input);
@@ -349,254 +349,214 @@ function resolve$1(input, base) {
     }
 }
 
-function resolve(input, base) {
-    // The base is always treated as a directory, if it's not empty.
-    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
-    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
-    if (base && !base.endsWith('/'))
-        base += '/';
-    return resolve$1(input, base);
-}
+// src/trace-mapping.ts
 
-/**
- * Removes everything after the last "/", but leaves the slash.
- */
+// src/strip-filename.ts
 function stripFilename(path) {
-    if (!path)
-        return '';
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
+  if (!path) return "";
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
 }
 
-const COLUMN = 0;
-const SOURCES_INDEX = 1;
-const SOURCE_LINE = 2;
-const SOURCE_COLUMN = 3;
-const NAMES_INDEX = 4;
+// src/resolve.ts
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => resolve(prefix + (source || ""), from);
+}
 
+// src/sourcemap-segment.ts
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+
+// src/sort.ts
 function maybeSort(mappings, owned) {
-    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
-    if (unsortedIndex === mappings.length)
-        return mappings;
-    // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
-    // not, we do not want to modify the consumer's input array.
-    if (!owned)
-        mappings = mappings.slice();
-    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
-        mappings[i] = sortSegments(mappings[i], owned);
-    }
-    return mappings;
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length) return mappings;
+  if (!owned) mappings = mappings.slice();
+  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+    mappings[i] = sortSegments(mappings[i], owned);
+  }
+  return mappings;
 }
 function nextUnsortedSegmentLine(mappings, start) {
-    for (let i = start; i < mappings.length; i++) {
-        if (!isSorted(mappings[i]))
-            return i;
-    }
-    return mappings.length;
+  for (let i = start; i < mappings.length; i++) {
+    if (!isSorted(mappings[i])) return i;
+  }
+  return mappings.length;
 }
 function isSorted(line) {
-    for (let j = 1; j < line.length; j++) {
-        if (line[j][COLUMN] < line[j - 1][COLUMN]) {
-            return false;
-        }
+  for (let j = 1; j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
     }
-    return true;
+  }
+  return true;
 }
 function sortSegments(line, owned) {
-    if (!owned)
-        line = line.slice();
-    return line.sort(sortComparator);
+  if (!owned) line = line.slice();
+  return line.sort(sortComparator);
 }
 function sortComparator(a, b) {
-    return a[COLUMN] - b[COLUMN];
+  return a[COLUMN] - b[COLUMN];
 }
 
-let found = false;
-/**
- * A binary search implementation that returns the index if a match is found.
- * If no match is found, then the left-index (the index associated with the item that comes just
- * before the desired index) is returned. To maintain proper sort order, a splice would happen at
- * the next index:
- *
- * ```js
- * const array = [1, 3];
- * const needle = 2;
- * const index = binarySearch(array, needle, (item, needle) => item - needle);
- *
- * assert.equal(index, 0);
- * array.splice(index + 1, 0, needle);
- * assert.deepEqual(array, [1, 2, 3]);
- * ```
- */
+// src/binary-search.ts
+var found = false;
 function binarySearch(haystack, needle, low, high) {
-    while (low <= high) {
-        const mid = low + ((high - low) >> 1);
-        const cmp = haystack[mid][COLUMN] - needle;
-        if (cmp === 0) {
-            found = true;
-            return mid;
-        }
-        if (cmp < 0) {
-            low = mid + 1;
-        }
-        else {
-            high = mid - 1;
-        }
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
     }
-    found = false;
-    return low - 1;
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
 }
 function upperBound(haystack, needle, index) {
-    for (let i = index + 1; i < haystack.length; index = i++) {
-        if (haystack[i][COLUMN] !== needle)
-            break;
-    }
-    return index;
+  for (let i = index + 1; i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
 }
 function lowerBound(haystack, needle, index) {
-    for (let i = index - 1; i >= 0; index = i--) {
-        if (haystack[i][COLUMN] !== needle)
-            break;
-    }
-    return index;
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
 }
 function memoizedState() {
-    return {
-        lastKey: -1,
-        lastNeedle: -1,
-        lastIndex: -1,
-    };
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
 }
-/**
- * This overly complicated beast is just to record the last tested line/column and the resulting
- * index, allowing us to skip a few tests if mappings are monotonically increasing.
- */
 function memoizedBinarySearch(haystack, needle, state, key) {
-    const { lastKey, lastNeedle, lastIndex } = state;
-    let low = 0;
-    let high = haystack.length - 1;
-    if (key === lastKey) {
-        if (needle === lastNeedle) {
-            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
-            return lastIndex;
-        }
-        if (needle >= lastNeedle) {
-            // lastIndex may be -1 if the previous needle was not found.
-            low = lastIndex === -1 ? 0 : lastIndex;
-        }
-        else {
-            high = lastIndex;
-        }
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
     }
-    state.lastKey = key;
-    state.lastNeedle = needle;
-    return (state.lastIndex = binarySearch(haystack, needle, low, high));
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
 }
 
-const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
-const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
-const LEAST_UPPER_BOUND = -1;
-const GREATEST_LOWER_BOUND = 1;
-class TraceMap {
-    constructor(map, mapUrl) {
-        const isString = typeof map === 'string';
-        if (!isString && map._decodedMemo)
-            return map;
-        const parsed = (isString ? JSON.parse(map) : map);
-        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
-        this.version = version;
-        this.file = file;
-        this.names = names || [];
-        this.sourceRoot = sourceRoot;
-        this.sources = sources;
-        this.sourcesContent = sourcesContent;
-        this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
-        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
-        this.resolvedSources = sources.map((s) => resolve(s || '', from));
-        const { mappings } = parsed;
-        if (typeof mappings === 'string') {
-            this._encoded = mappings;
-            this._decoded = undefined;
-        }
-        else {
-            this._encoded = undefined;
-            this._decoded = maybeSort(mappings, isString);
-        }
-        this._decodedMemo = memoizedState();
-        this._bySources = undefined;
-        this._bySourceMemos = undefined;
-    }
+// src/types.ts
+function parse(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
 }
-/**
- * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
- * with public access modifiers.
- */
+
+// src/trace-mapping.ts
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo) return map;
+    const parsed = parse(map);
+    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+    const resolve = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = void 0;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = void 0;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = void 0;
+    this._bySourceMemos = void 0;
+  }
+};
 function cast(map) {
-    return map;
+  return map;
 }
-/**
- * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
- */
 function decodedMappings(map) {
-    var _a;
-    return ((_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded)));
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
 }
-/**
- * A higher-level API to find the source/line/column associated with a generated line/column
- * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
- * `source-map` library.
- */
 function originalPositionFor(map, needle) {
-    let { line, column, bias } = needle;
-    line--;
-    if (line < 0)
-        throw new Error(LINE_GTR_ZERO);
-    if (column < 0)
-        throw new Error(COL_GTR_EQ_ZERO);
-    const decoded = decodedMappings(map);
-    // It's common for parent source maps to have pointers to lines that have no
-    // mapping (like a "//# sourceMappingURL=") at the end of the child file.
-    if (line >= decoded.length)
-        return OMapping(null, null, null, null);
-    const segments = decoded[line];
-    const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
-    if (index === -1)
-        return OMapping(null, null, null, null);
-    const segment = segments[index];
-    if (segment.length === 1)
-        return OMapping(null, null, null, null);
-    const { names, resolvedSources } = map;
-    return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0) throw new Error(LINE_GTR_ZERO);
+  if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length) return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(
+    segments,
+    cast(map)._decodedMemo,
+    line,
+    column,
+    bias || GREATEST_LOWER_BOUND
+  );
+  if (index === -1) return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1) return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(
+    resolvedSources[segment[SOURCES_INDEX]],
+    segment[SOURCE_LINE] + 1,
+    segment[SOURCE_COLUMN],
+    segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+  );
 }
 function OMapping(source, line, column, name) {
-    return { source, line, column, name };
+  return { source, line, column, name };
 }
 function traceSegmentInternal(segments, memo, line, column, bias) {
-    let index = memoizedBinarySearch(segments, column, memo, line);
-    if (found) {
-        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
-    }
-    else if (bias === LEAST_UPPER_BOUND)
-        index++;
-    if (index === -1 || index === segments.length)
-        return -1;
-    return index;
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND) index++;
+  if (index === -1 || index === segments.length) return -1;
+  return index;
 }
 
 // Only install once if called multiple times
 let errorFormatterInstalled = false;
 // Maps a file path to a string containing the file contents
-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,/;
+const fileContentsCache = {}, sourceMapCache = {}, reSourceMap = /^data:application\/json[^,]+base64,/;
 // Priority list of retrieve handlers
-let retrieveFileHandlers = [];
-let retrieveMapHandlers = [];
+let retrieveFileHandlers = [], retrieveMapHandlers = [];
 function globalProcessVersion() {
-	if (typeof process === "object" && process !== null) return process.version;
-	else return "";
+	return typeof process === "object" && process !== null ? process.version : "";
 }
 function handlerExec(list) {
 	return function(arg) {
@@ -609,9 +569,7 @@ function handlerExec(list) {
 }
 let retrieveFile = handlerExec(retrieveFileHandlers);
 retrieveFileHandlers.push((path) => {
-	// Trim the path to make sure there is no extra whitespace.
-	path = path.trim();
-	if (path.startsWith("file:"))
+	if (path = path.trim(), path.startsWith("file:"))
  // existsSync/readFileSync can't handle file protocol, but once stripped, it works
 	path = path.replace(/file:\/\/\/(\w:)?/, (protocol, drive) => {
 		return drive ? "" : "/";
@@ -626,16 +584,10 @@ 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);
-	const match = /^\w+:\/\/[^/]*/.exec(dir);
+	const dir = path.dirname(file), match = /^\w+:\/\/[^/]*/.exec(dir);
 	let protocol = match ? match[0] : "";
 	const startPath = dir.slice(protocol.length);
-	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);
+	return protocol && /^\/\w:/.test(startPath) ? (protocol += "/", protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/")) : protocol + path.resolve(dir.slice(protocol.length), url);
 }
 function retrieveSourceMapURL(source) {
 	// Get the URL of the source map
@@ -647,8 +599,7 @@ function retrieveSourceMapURL(source) {
 	let lastMatch, match;
 	// eslint-disable-next-line no-cond-assign
 	while (match = re.exec(fileData)) lastMatch = match;
-	if (!lastMatch) return null;
-	return lastMatch[1];
+	return lastMatch ? lastMatch[1] : null;
 }
 // Can be overridden by the retrieveSourceMap option to install. Takes a
 // generated source filename; returns a {map, optional url} object, or null if
@@ -664,18 +615,12 @@ 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 {
-		// Support source map URLs relative to the source URL
-		sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
-		sourceMapData = retrieveFile(sourceMappingURL);
-	}
-	if (!sourceMapData) return null;
-	return {
+		sourceMapData = Buffer.from(rawData, "base64").toString(), sourceMappingURL = source;
+	} else sourceMappingURL = supportRelativeURL(source, sourceMappingURL), sourceMapData = retrieveFile(sourceMappingURL);
+	return sourceMapData ? {
 		url: sourceMappingURL,
 		map: sourceMapData
-	};
+	} : null;
 });
 // interface Position {
 //   source: string
@@ -687,17 +632,15 @@ 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);
-		const map = urlAndMap && urlAndMap.map;
+		const urlAndMap = retrieveSourceMap(position.source), map = urlAndMap && urlAndMap.map;
 		if (map && !(typeof map === "object" && "mappings" in map && map.mappings === "")) {
 			var _sourceMap$map;
-			sourceMap = sourceMapCache[position.source] = {
-				url: urlAndMap.url,
-				map: new TraceMap(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$map = sourceMap.map) === null || _sourceMap$map === void 0 ? void 0 : _sourceMap$map.sourcesContent) sourceMap.map.sources.forEach((source, i) => {
+			if (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) => {
 				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) {
@@ -718,10 +661,7 @@ 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) {
-			originalPosition.source = supportRelativeURL(sourceMap.url, originalPosition.source);
-			return originalPosition;
-		}
+		if (originalPosition.source !== null) return originalPosition.source = supportRelativeURL(sourceMap.url, originalPosition.source), originalPosition;
 	}
 	return position;
 }
@@ -739,11 +679,8 @@ 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 origin;
+	return match = /^eval at ([^(]+) \((.+)\)$/.exec(origin), match ? `eval at ${match[1]} (${mapEvalOrigin(match[2])})` : 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
@@ -752,15 +689,10 @@ 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;
-	let fileLocation = "";
+	let fileName, fileLocation = "";
 	if (this.isNative()) fileLocation = "native";
 	else {
-		fileName = this.getScriptNameOrSourceURL();
-		if (!fileName && this.isEval()) {
-			fileLocation = this.getEvalOrigin();
-			fileLocation += ", ";
-		}
+		if (fileName = this.getScriptNameOrSourceURL(), !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
@@ -777,8 +709,7 @@ function CallSiteToString() {
 	let line = "";
 	const functionName = this.getFunctionName();
 	let addSuffix = true;
-	const isConstructor = this.isConstructor();
-	const isMethodCall = !(this.isToplevel() || isConstructor);
+	const isConstructor = this.isConstructor(), isMethodCall = !(this.isToplevel() || isConstructor);
 	if (isMethodCall) {
 		let typeName = this.getTypeName();
 		// Fixes shim to be backward compatible with Node v0 to v4
@@ -786,30 +717,24 @@ function CallSiteToString() {
 		const methodName = this.getMethodName();
 		if (functionName) {
 			if (typeName && functionName.indexOf(typeName) !== 0) line += `${typeName}.`;
-			line += functionName;
-			if (methodName && functionName.indexOf(`.${methodName}`) !== functionName.length - methodName.length - 1) line += ` [as ${methodName}]`;
+			if (line += functionName, 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 = {};
-	Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach((name) => {
+	return 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;
-	return object;
+	}), object.toString = CallSiteToString, object;
 }
 function wrapCallSite(frame, state) {
 	// provides interface backward compatibility
@@ -817,10 +742,7 @@ function wrapCallSite(frame, state) {
 		nextPosition: null,
 		curPosition: null
 	};
-	if (frame.isNative()) {
-		state.curPosition = null;
-		return frame;
-	}
+	if (frame.isNative()) return state.curPosition = null, 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
@@ -833,8 +755,7 @@ function wrapCallSite(frame, state) {
 		// 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)/;
-		const headerLength = noHeader.test(globalProcessVersion()) ? 0 : 62;
+		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;
 		if (line === 1 && column > headerLength && !frame.isEval()) column -= headerLength;
 		const position = mapSourcePosition({
 			name: null,
@@ -842,65 +763,42 @@ function wrapCallSite(frame, state) {
 			line,
 			column
 		});
-		state.curPosition = position;
-		frame = cloneCallSite(frame);
+		state.curPosition = position, frame = cloneCallSite(frame);
 		const originalFunctionName = frame.getFunctionName;
-		frame.getFunctionName = function() {
-			if (state.nextPosition == null) return originalFunctionName();
-			return state.nextPosition.name || originalFunctionName();
-		};
-		frame.getFileName = function() {
+		return frame.getFunctionName = function() {
+			return state.nextPosition == null ? originalFunctionName() : 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;
-		};
-		return frame;
+		}, 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 frame;
+	return origin ? (origin = mapEvalOrigin(origin), frame = cloneCallSite(frame), frame.getEvalOrigin = function() {
+		return origin || void 0;
+	}, frame) : 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";
-	const message = error.message || "";
-	const errorString = `${name}: ${message}`;
-	const state = {
+	const name = error.name || "Error", message = error.message || "", errorString = `${name}: ${message}`, state = {
 		nextPosition: null,
 		curPosition: null
-	};
-	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("");
+	}, 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("");
 }
-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.retrieveFile) {
+	if (options = options || {}, options.retrieveFile) {
 		if (options.overrideRetrieveFile) retrieveFileHandlers.length = 0;
 		retrieveFileHandlers.unshift(options.retrieveFile);
 	}
@@ -911,16 +809,12 @@ 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";
-const VITE_NODE_SOURCEMAPPING_URL = `${SOURCEMAPPING_URL}=data:application/json;charset=utf-8`;
+const VITE_NODE_SOURCEMAPPING_SOURCE = "//# sourceMappingSource=vite-node", VITE_NODE_SOURCEMAPPING_URL = `${SOURCEMAPPING_URL}=data:application/json;charset=utf-8`;
 function withInlineSourcemap(result, options) {
 	const map = result.map;
 	let code = result.code;
@@ -949,26 +843,22 @@ 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");
-	result.code = `${code.trimEnd()}\n\n${VITE_NODE_SOURCEMAPPING_SOURCE}\n//# ${VITE_NODE_SOURCEMAPPING_URL};base64,${sourceMap}\n`;
-	return result;
+	return result.code = `${code.trimEnd()}\n\n${VITE_NODE_SOURCEMAPPING_SOURCE}\n//# ${VITE_NODE_SOURCEMAPPING_URL};base64,${sourceMap}\n`, 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;
-	// 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;
+	return lastMatch ? JSON.parse(Buffer.from(lastMatch[1], "base64").toString("utf-8")) : null;
 }
 function installSourcemapsSupport(options) {
 	install({ retrieveSourceMap(source) {
 		const map = options.getSourceMap(source);
-		if (map) return {
+		return map ? {
 			url: source,
 			map
-		};
-		return null;
+		} : null;
 	} });
 }