939 lines
32 KiB
JavaScript
939 lines
32 KiB
JavaScript
const { TraceMap, originalPositionFor, AnyMap } = require('@jridgewell/trace-mapping');
|
|
var path = require('path');
|
|
const { fileURLToPath, pathToFileURL } = require('url');
|
|
var util = require('util');
|
|
|
|
var fs;
|
|
try {
|
|
fs = require('fs');
|
|
if (!fs.existsSync || !fs.readFileSync) {
|
|
// fs doesn't have all methods we need
|
|
fs = null;
|
|
}
|
|
} catch (err) {
|
|
/* nop */
|
|
}
|
|
|
|
/**
|
|
* Requires a module which is protected against bundler minification.
|
|
*
|
|
* @param {NodeModule} mod
|
|
* @param {string} request
|
|
*/
|
|
function dynamicRequire(mod, request) {
|
|
return mod.require(request);
|
|
}
|
|
|
|
/**
|
|
* @typedef {{
|
|
* enabled: boolean;
|
|
* originalValue: any;
|
|
* installedValue: any;
|
|
* }} HookState
|
|
* Used for installing and uninstalling hooks
|
|
*/
|
|
|
|
// Increment this if the format of sharedData changes in a breaking way.
|
|
var sharedDataVersion = 1;
|
|
|
|
/**
|
|
* @template T
|
|
* @param {T} defaults
|
|
* @returns {T}
|
|
*/
|
|
function initializeSharedData(defaults) {
|
|
var sharedDataKey = 'source-map-support/sharedData';
|
|
if (typeof Symbol !== 'undefined') {
|
|
sharedDataKey = Symbol.for(sharedDataKey);
|
|
}
|
|
var sharedData = this[sharedDataKey];
|
|
if (!sharedData) {
|
|
sharedData = { version: sharedDataVersion };
|
|
if (Object.defineProperty) {
|
|
Object.defineProperty(this, sharedDataKey, { value: sharedData });
|
|
} else {
|
|
this[sharedDataKey] = sharedData;
|
|
}
|
|
}
|
|
if (sharedDataVersion !== sharedData.version) {
|
|
throw new Error("Multiple incompatible instances of source-map-support were loaded");
|
|
}
|
|
for (var key in defaults) {
|
|
if (!(key in sharedData)) {
|
|
sharedData[key] = defaults[key];
|
|
}
|
|
}
|
|
return sharedData;
|
|
}
|
|
|
|
// If multiple instances of source-map-support are loaded into the same
|
|
// context, they shouldn't overwrite each other. By storing handlers, caches,
|
|
// and other state on a shared object, different instances of
|
|
// source-map-support can work together in a limited way. This does require
|
|
// that future versions of source-map-support continue to support the fields on
|
|
// this object. If this internal contract ever needs to be broken, increment
|
|
// sharedDataVersion. (This version number is not the same as any of the
|
|
// package's version numbers, which should reflect the *external* API of
|
|
// source-map-support.)
|
|
var sharedData = initializeSharedData({
|
|
|
|
// Only install once if called multiple times
|
|
// Remember how the environment looked before installation so we can restore if able
|
|
/** @type {HookState} */
|
|
errorPrepareStackTraceHook: undefined,
|
|
/** @type {HookState} */
|
|
processEmitHook: undefined,
|
|
/** @type {HookState} */
|
|
moduleResolveFilenameHook: undefined,
|
|
|
|
/** @type {Array<(request: string, parent: any, isMain: boolean, options: any, redirectedRequest: string) => void>} */
|
|
onConflictingLibraryRedirectArr: [],
|
|
|
|
// If true, the caches are reset before a stack trace formatting operation
|
|
emptyCacheBetweenOperations: false,
|
|
|
|
// Maps a file path to a string containing the file contents
|
|
fileContentsCache: Object.create(null),
|
|
|
|
// Maps a file path to a source map for that file
|
|
/** @type {Record<string, {url: string, map: TraceMap}} */
|
|
sourceMapCache: Object.create(null),
|
|
|
|
// Priority list of retrieve handlers
|
|
retrieveFileHandlers: [],
|
|
retrieveMapHandlers: [],
|
|
|
|
// Priority list of internally-implemented handlers.
|
|
// When resetting state, we must keep these.
|
|
internalRetrieveFileHandlers: [],
|
|
internalRetrieveMapHandlers: [],
|
|
|
|
});
|
|
|
|
// Supports {browser, node, auto}
|
|
var environment = "auto";
|
|
|
|
// Regex for detecting source maps
|
|
var reSourceMap = /^data:application\/json[^,]+base64,/;
|
|
|
|
function isInBrowser() {
|
|
if (environment === "browser")
|
|
return true;
|
|
if (environment === "node")
|
|
return false;
|
|
return ((typeof window !== 'undefined') && (typeof XMLHttpRequest === 'function') && !(window.require && window.module && window.process && window.process.type === "renderer"));
|
|
}
|
|
|
|
function hasGlobalProcessEventEmitter() {
|
|
return ((typeof process === 'object') && (process !== null) && (typeof process.on === 'function'));
|
|
}
|
|
|
|
function tryFileURLToPath(v) {
|
|
if(isFileUrl(v)) {
|
|
return fileURLToPath(v);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
// TODO un-copy these from resolve-uri; see if they can be exported from that lib
|
|
function isFileUrl(input) {
|
|
return input.startsWith('file:');
|
|
}
|
|
function isAbsoluteUrl(input) {
|
|
return schemeRegex.test(input);
|
|
}
|
|
// Matches the scheme of a URL, eg "http://"
|
|
const schemeRegex = /^[\w+.-]+:\/\//;
|
|
function isSchemeRelativeUrl(input) {
|
|
return input.startsWith('//');
|
|
}
|
|
|
|
// #region Caches
|
|
/** @param {string} pathOrFileUrl */
|
|
function getCacheKey(pathOrFileUrl) {
|
|
if(pathOrFileUrl.startsWith('node:')) return pathOrFileUrl;
|
|
if(isFileUrl(pathOrFileUrl)) {
|
|
// Must normalize spaces to %20, stuff like that
|
|
return new URL(pathOrFileUrl).toString();
|
|
} else {
|
|
try {
|
|
return pathToFileURL(pathOrFileUrl).toString();
|
|
} catch {
|
|
return pathOrFileUrl;
|
|
}
|
|
}
|
|
}
|
|
function getFileContentsCache(key) {
|
|
return sharedData.fileContentsCache[getCacheKey(key)];
|
|
}
|
|
function hasFileContentsCacheFromKey(key) {
|
|
return Object.prototype.hasOwnProperty.call(sharedData.fileContentsCache, key);
|
|
}
|
|
function getFileContentsCacheFromKey(key) {
|
|
return sharedData.fileContentsCache[key];
|
|
}
|
|
function setFileContentsCache(key, value) {
|
|
return sharedData.fileContentsCache[getCacheKey(key)] = value;
|
|
}
|
|
function getSourceMapCache(key) {
|
|
return sharedData.sourceMapCache[getCacheKey(key)];
|
|
}
|
|
function setSourceMapCache(key, value) {
|
|
return sharedData.sourceMapCache[getCacheKey(key)] = value;
|
|
}
|
|
function clearCaches() {
|
|
sharedData.fileContentsCache = Object.create(null);
|
|
sharedData.sourceMapCache = Object.create(null);
|
|
}
|
|
// #endregion Caches
|
|
|
|
function handlerExec(list, internalList) {
|
|
return function(arg) {
|
|
for (var i = 0; i < list.length; i++) {
|
|
var ret = list[i](arg);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
}
|
|
for (var i = 0; i < internalList.length; i++) {
|
|
var ret = internalList[i](arg);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
var retrieveFile = handlerExec(sharedData.retrieveFileHandlers, sharedData.internalRetrieveFileHandlers);
|
|
|
|
sharedData.internalRetrieveFileHandlers.push(function(path) {
|
|
// Trim the path to make sure there is no extra whitespace.
|
|
path = path.trim();
|
|
if (/^file:/.test(path)) {
|
|
// existsSync/readFileSync can't handle file protocol, but once stripped, it works
|
|
path = path.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
|
|
return drive ?
|
|
'' : // file:///C:/dir/file -> C:/dir/file
|
|
'/'; // file:///root-dir/file -> /root-dir/file
|
|
});
|
|
}
|
|
const key = getCacheKey(path);
|
|
if(hasFileContentsCacheFromKey(key)) {
|
|
return getFileContentsCacheFromKey(key);
|
|
}
|
|
|
|
var contents = '';
|
|
try {
|
|
if (!fs) {
|
|
// Use SJAX if we are in the browser
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', path, /** async */ false);
|
|
xhr.send(null);
|
|
if (xhr.readyState === 4 && xhr.status === 200) {
|
|
contents = xhr.responseText;
|
|
}
|
|
} else if (fs.existsSync(path)) {
|
|
// Otherwise, use the filesystem
|
|
contents = fs.readFileSync(path, 'utf8');
|
|
}
|
|
} catch (er) {
|
|
/* ignore any errors */
|
|
}
|
|
|
|
return setFileContentsCache(path, contents);
|
|
});
|
|
|
|
// Support URLs relative to a directory, but be careful about a protocol prefix
|
|
// in case we are in the browser (i.e. directories may start with "http://" or "file:///")
|
|
function supportRelativeURL(file, url) {
|
|
if(!file) return url;
|
|
// given that this happens within error formatting codepath, probably best to
|
|
// fallback instead of throwing if anything goes wrong
|
|
try {
|
|
// if should output a URL
|
|
if(isAbsoluteUrl(file) || isSchemeRelativeUrl(file)) {
|
|
if(isAbsoluteUrl(url) || isSchemeRelativeUrl(url)) {
|
|
return new URL(url, file).toString();
|
|
}
|
|
if(path.isAbsolute(url)) {
|
|
return new URL(pathToFileURL(url), file).toString();
|
|
}
|
|
// url is relative path or URL
|
|
return new URL(url.replace(/\\/g, '/'), file).toString();
|
|
}
|
|
// if should output a path (unless URL is something like https://)
|
|
if(path.isAbsolute(file)) {
|
|
if(isFileUrl(url)) {
|
|
return fileURLToPath(url);
|
|
}
|
|
if(isSchemeRelativeUrl(url)) {
|
|
return fileURLToPath(new URL(url, 'file://'));
|
|
}
|
|
if(isAbsoluteUrl(url)) {
|
|
// url is a non-file URL
|
|
// Go with the URL
|
|
return url;
|
|
}
|
|
if(path.isAbsolute(url)) {
|
|
// Normalize at all? decodeURI or normalize slashes?
|
|
return path.normalize(url);
|
|
}
|
|
// url is relative path or URL
|
|
return path.join(file, '..', decodeURI(url));
|
|
}
|
|
// If we get here, file is relative.
|
|
// Shouldn't happen since node identifies modules with absolute paths or URLs.
|
|
// But we can take a stab at returning something meaningful anyway.
|
|
if(isAbsoluteUrl(url) || isSchemeRelativeUrl(url)) {
|
|
return url;
|
|
}
|
|
return path.join(file, '..', url);
|
|
} catch(e) {
|
|
return url;
|
|
}
|
|
}
|
|
|
|
// Return pathOrUrl in the same style as matchStyleOf: either a file URL or a native path
|
|
function matchStyleOfPathOrUrl(matchStyleOf, pathOrUrl) {
|
|
try {
|
|
if(isAbsoluteUrl(matchStyleOf) || isSchemeRelativeUrl(matchStyleOf)) {
|
|
if(isAbsoluteUrl(pathOrUrl) || isSchemeRelativeUrl(pathOrUrl)) return pathOrUrl;
|
|
if(path.isAbsolute(pathOrUrl)) return pathToFileURL(pathOrUrl).toString();
|
|
} else if(path.isAbsolute(matchStyleOf)) {
|
|
if(isAbsoluteUrl(pathOrUrl) || isSchemeRelativeUrl(pathOrUrl)) {
|
|
return fileURLToPath(new URL(pathOrUrl, 'file://'));
|
|
}
|
|
}
|
|
return pathOrUrl;
|
|
} catch(e) {
|
|
return pathOrUrl;
|
|
}
|
|
}
|
|
|
|
function retrieveSourceMapURL(source) {
|
|
var fileData;
|
|
|
|
if (isInBrowser()) {
|
|
try {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', source, false);
|
|
xhr.send(null);
|
|
fileData = xhr.readyState === 4 ? xhr.responseText : null;
|
|
|
|
// Support providing a sourceMappingURL via the SourceMap header
|
|
var sourceMapHeader = xhr.getResponseHeader("SourceMap") ||
|
|
xhr.getResponseHeader("X-SourceMap");
|
|
if (sourceMapHeader) {
|
|
return sourceMapHeader;
|
|
}
|
|
} catch (e) {
|
|
}
|
|
}
|
|
|
|
// Get the URL of the source map
|
|
fileData = retrieveFile(tryFileURLToPath(source));
|
|
var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;
|
|
// Keep executing the search to find the *last* sourceMappingURL to avoid
|
|
// picking up sourceMappingURLs from comments, strings, etc.
|
|
var lastMatch, match;
|
|
while (match = re.exec(fileData)) lastMatch = match;
|
|
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
|
|
// there is no source map. The map field may be either a string or the parsed
|
|
// JSON object (ie, it must be a valid argument to the SourceMapConsumer
|
|
// constructor).
|
|
/** @type {(source: string) => import('./source-map-support').UrlAndMap | null} */
|
|
var retrieveSourceMap = handlerExec(sharedData.retrieveMapHandlers, sharedData.internalRetrieveMapHandlers);
|
|
sharedData.internalRetrieveMapHandlers.push(function(source) {
|
|
var sourceMappingURL = retrieveSourceMapURL(source);
|
|
if (!sourceMappingURL) return null;
|
|
|
|
// Read the contents of the source map
|
|
var sourceMapData;
|
|
if (reSourceMap.test(sourceMappingURL)) {
|
|
// Support source map URL as a data url
|
|
var 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(tryFileURLToPath(sourceMappingURL));
|
|
}
|
|
|
|
if (!sourceMapData) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
url: sourceMappingURL,
|
|
map: sourceMapData
|
|
};
|
|
});
|
|
|
|
function mapSourcePosition(position) {
|
|
var sourceMap = getSourceMapCache(position.source);
|
|
if (!sourceMap) {
|
|
// Call the (overrideable) retrieveSourceMap function to get the source map.
|
|
var urlAndMap = retrieveSourceMap(position.source);
|
|
if (urlAndMap) {
|
|
sourceMap = setSourceMapCache(position.source, {
|
|
url: urlAndMap.url,
|
|
map: new AnyMap(urlAndMap.map, urlAndMap.url)
|
|
});
|
|
|
|
// Overwrite trace-mapping's resolutions, because they do not handle
|
|
// Windows paths the way we want.
|
|
// TODO Remove now that windows path support was added to resolve-uri and thus trace-mapping?
|
|
sourceMap.map.resolvedSources = sourceMap.map.sources.map(s => supportRelativeURL(sourceMap.url, s));
|
|
|
|
// 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.sourcesContent) {
|
|
sourceMap.map.resolvedSources.forEach(function(resolvedSource, i) {
|
|
var contents = sourceMap.map.sourcesContent[i];
|
|
if (contents) {
|
|
setFileContentsCache(resolvedSource, contents);
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
sourceMap = setSourceMapCache(position.source, {
|
|
url: null,
|
|
map: null
|
|
});
|
|
}
|
|
}
|
|
|
|
// Resolve the source URL relative to the URL of the source map
|
|
if (sourceMap && sourceMap.map) {
|
|
var originalPosition = originalPositionFor(sourceMap.map, position);
|
|
|
|
// Only return the original position if a matching line was found. If no
|
|
// matching line is found then we return position instead, which will cause
|
|
// 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 has *already* been resolved against sourceMap.url
|
|
// so is *already* as absolute as possible.
|
|
// However, we want to ensure we output in same format as input: URL or native path
|
|
originalPosition.source = matchStyleOfPathOrUrl(
|
|
position.source, originalPosition.source);
|
|
return originalPosition;
|
|
}
|
|
}
|
|
|
|
return position;
|
|
}
|
|
|
|
// Parses code generated by FormatEvalOrigin(), a function inside V8:
|
|
// https://code.google.com/p/v8/source/browse/trunk/src/messages.js
|
|
function mapEvalOrigin(origin) {
|
|
// Most eval() calls are in this format
|
|
var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
|
|
if (match) {
|
|
var position = mapSourcePosition({
|
|
source: match[2],
|
|
line: +match[3],
|
|
column: match[4] - 1
|
|
});
|
|
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;
|
|
}
|
|
|
|
// This is copied almost verbatim from the V8 source code at
|
|
// https://code.google.com/p/v8/source/browse/trunk/src/messages.js
|
|
// Update 2022-04-29:
|
|
// https://github.com/v8/v8/blob/98f6f100c5ab8e390e51422747c4ef644d5ac6f2/src/builtins/builtins-callsite.cc#L175-L179
|
|
// https://github.com/v8/v8/blob/98f6f100c5ab8e390e51422747c4ef644d5ac6f2/src/objects/call-site-info.cc#L795-L804
|
|
// https://github.com/v8/v8/blob/98f6f100c5ab8e390e51422747c4ef644d5ac6f2/src/objects/call-site-info.cc#L717-L750
|
|
// The implementation of wrapCallSite() used to just forward to the actual source
|
|
// code of CallSite.prototype.toString but unfortunately a new release of V8
|
|
// did something to the prototype chain and broke the shim. The only fix I
|
|
// could find was copy/paste.
|
|
function CallSiteToString() {
|
|
var fileName;
|
|
var fileLocation = "";
|
|
if (this.isNative()) {
|
|
fileLocation = "native";
|
|
} else {
|
|
fileName = this.getScriptNameOrSourceURL();
|
|
if (!fileName && this.isEval()) {
|
|
fileLocation = this.getEvalOrigin();
|
|
fileLocation += ", "; // Expecting source position to follow.
|
|
}
|
|
|
|
if (fileName) {
|
|
fileLocation += fileName;
|
|
} else {
|
|
// Source code does not originate from a file and is not native, but we
|
|
// can still get the source position inside the source string, e.g. in
|
|
// an eval string.
|
|
fileLocation += "<anonymous>";
|
|
}
|
|
var lineNumber = this.getLineNumber();
|
|
if (lineNumber != null) {
|
|
fileLocation += ":" + lineNumber;
|
|
var columnNumber = this.getColumnNumber();
|
|
if (columnNumber) {
|
|
fileLocation += ":" + columnNumber;
|
|
}
|
|
}
|
|
}
|
|
|
|
var line = "";
|
|
var isAsync = this.isAsync ? this.isAsync() : false;
|
|
if(isAsync) {
|
|
line += 'async ';
|
|
var isPromiseAll = this.isPromiseAll ? this.isPromiseAll() : false;
|
|
var isPromiseAny = this.isPromiseAny ? this.isPromiseAny() : false;
|
|
if(isPromiseAny || isPromiseAll) {
|
|
line += isPromiseAll ? 'Promise.all (index ' : 'Promise.any (index ';
|
|
var promiseIndex = this.getPromiseIndex();
|
|
line += promiseIndex + ')';
|
|
}
|
|
}
|
|
var functionName = this.getFunctionName();
|
|
var addSuffix = true;
|
|
var isConstructor = this.isConstructor();
|
|
var isMethodCall = !(this.isToplevel() || isConstructor);
|
|
if (isMethodCall) {
|
|
var typeName = this.getTypeName();
|
|
// Fixes shim to be backward compatable with Node v0 to v4
|
|
if (typeName === "[object Object]") {
|
|
typeName = "null";
|
|
}
|
|
var 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 + "]";
|
|
}
|
|
} else {
|
|
line += typeName + "." + (methodName || "<anonymous>");
|
|
}
|
|
} else if (isConstructor) {
|
|
line += "new " + (functionName || "<anonymous>");
|
|
} else if (functionName) {
|
|
line += functionName;
|
|
} else {
|
|
line += fileLocation;
|
|
addSuffix = false;
|
|
}
|
|
if (addSuffix) {
|
|
line += " (" + fileLocation + ")";
|
|
}
|
|
return line;
|
|
}
|
|
|
|
function cloneCallSite(frame) {
|
|
var object = {};
|
|
Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function(name) {
|
|
object[name] = /^(?:is|get)/.test(name) ? function() { return frame[name].call(frame); } : frame[name];
|
|
});
|
|
object.toString = CallSiteToString;
|
|
return object;
|
|
}
|
|
|
|
function wrapCallSite(frame, state) {
|
|
// provides interface backward compatibility
|
|
if (state === undefined) {
|
|
state = { nextPosition: null, curPosition: null }
|
|
}
|
|
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
|
|
var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
|
|
if (source) {
|
|
// v8 does not expose its internal isWasm, etc methods, so we do this instead.
|
|
if(source.startsWith('wasm://')) {
|
|
state.curPosition = null;
|
|
return frame;
|
|
}
|
|
|
|
var line = frame.getLineNumber();
|
|
var 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
|
|
var noHeader = /^v(10\.1[6-9]|10\.[2-9][0-9]|10\.[0-9]{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/;
|
|
var headerLength = noHeader.test(process.version) ? 0 : 62;
|
|
if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) {
|
|
column -= headerLength;
|
|
}
|
|
|
|
var position = mapSourcePosition({
|
|
source: source,
|
|
line: line,
|
|
column: column
|
|
});
|
|
state.curPosition = position;
|
|
frame = cloneCallSite(frame);
|
|
var originalFunctionName = frame.getFunctionName;
|
|
frame.getFunctionName = function() {
|
|
if (state.nextPosition == null) {
|
|
return originalFunctionName();
|
|
}
|
|
return state.nextPosition.name || originalFunctionName();
|
|
};
|
|
frame.getFileName = function() { return position.source; };
|
|
frame.getLineNumber = function() { return position.line; };
|
|
frame.getColumnNumber = function() { return position.column + 1; };
|
|
frame.getScriptNameOrSourceURL = function() { return position.source; };
|
|
return frame;
|
|
}
|
|
|
|
// Code called using eval() needs special handling
|
|
var origin = frame.isEval() && frame.getEvalOrigin();
|
|
if (origin) {
|
|
origin = mapEvalOrigin(origin);
|
|
frame = cloneCallSite(frame);
|
|
frame.getEvalOrigin = function() { return origin; };
|
|
return frame;
|
|
}
|
|
|
|
// If we get here then we were unable to change the source position
|
|
return frame;
|
|
}
|
|
|
|
var kIsNodeError = undefined;
|
|
try {
|
|
// Get a deliberate ERR_INVALID_ARG_TYPE
|
|
// TODO is there a better way to reliably get an instance of NodeError?
|
|
path.resolve(123);
|
|
} catch(e) {
|
|
const symbols = Object.getOwnPropertySymbols(e);
|
|
const symbol = symbols.find(function (s) {return s.toString().indexOf('kIsNodeError') >= 0});
|
|
if(symbol) kIsNodeError = symbol;
|
|
}
|
|
|
|
const ErrorPrototypeToString = (err) =>Error.prototype.toString.call(err);
|
|
|
|
/** @param {HookState} hookState */
|
|
function createPrepareStackTrace(hookState) {
|
|
return prepareStackTrace;
|
|
|
|
// 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) {
|
|
if(!hookState.enabled) return hookState.originalValue.apply(this, arguments);
|
|
|
|
if (sharedData.emptyCacheBetweenOperations) {
|
|
clearCaches();
|
|
}
|
|
|
|
// node gives its own errors special treatment. Mimic that behavior
|
|
// https://github.com/nodejs/node/blob/3cbaabc4622df1b4009b9d026a1a970bdbae6e89/lib/internal/errors.js#L118-L128
|
|
// https://github.com/nodejs/node/pull/39182
|
|
var errorString;
|
|
if (kIsNodeError) {
|
|
if(kIsNodeError in error) {
|
|
errorString = `${error.name} [${error.code}]: ${error.message}`;
|
|
} else {
|
|
errorString = ErrorPrototypeToString(error);
|
|
}
|
|
} else {
|
|
var name = error.name || 'Error';
|
|
var message = error.message || '';
|
|
errorString = message ? name + ": " + message : name;
|
|
}
|
|
|
|
var state = { nextPosition: null, curPosition: null };
|
|
var processedStack = [];
|
|
for (var 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('');
|
|
}
|
|
}
|
|
|
|
// Generate position and snippet of original source with pointer
|
|
function getErrorSource(error) {
|
|
var match = /\n at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
|
|
if (match) {
|
|
var source = match[1];
|
|
var line = +match[2];
|
|
var column = +match[3];
|
|
|
|
// Support the inline sourceContents inside the source map
|
|
var contents = getFileContentsCache(source);
|
|
|
|
const sourceAsPath = tryFileURLToPath(source);
|
|
|
|
// Support files on disk
|
|
if (!contents && fs && fs.existsSync(sourceAsPath)) {
|
|
try {
|
|
contents = fs.readFileSync(sourceAsPath, 'utf8');
|
|
} catch (er) {
|
|
contents = '';
|
|
}
|
|
}
|
|
|
|
// Format the line from the original source code like node does
|
|
if (contents) {
|
|
var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
|
|
if (code) {
|
|
return source + ':' + line + '\n' + code + '\n' +
|
|
new Array(column).join(' ') + '^';
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function printFatalErrorUponExit (error) {
|
|
var source = getErrorSource(error);
|
|
|
|
// Ensure error is printed synchronously and not truncated
|
|
if (process.stderr._handle && process.stderr._handle.setBlocking) {
|
|
process.stderr._handle.setBlocking(true);
|
|
}
|
|
|
|
if (source) {
|
|
console.error(source);
|
|
}
|
|
|
|
// Matches node's behavior for colorized output
|
|
console.error(
|
|
util.inspect(error, {
|
|
customInspect: false,
|
|
colors: process.stderr.isTTY
|
|
})
|
|
);
|
|
}
|
|
|
|
function shimEmitUncaughtException () {
|
|
const originalValue = process.emit;
|
|
var hook = sharedData.processEmitHook = {
|
|
enabled: true,
|
|
originalValue,
|
|
installedValue: undefined
|
|
};
|
|
var isTerminatingDueToFatalException = false;
|
|
var fatalException;
|
|
|
|
process.emit = sharedData.processEmitHook.installedValue = function (type) {
|
|
const hadListeners = originalValue.apply(this, arguments);
|
|
if(hook.enabled) {
|
|
if (type === 'uncaughtException' && !hadListeners) {
|
|
isTerminatingDueToFatalException = true;
|
|
fatalException = arguments[1];
|
|
process.exit(1);
|
|
}
|
|
if (type === 'exit' && isTerminatingDueToFatalException) {
|
|
printFatalErrorUponExit(fatalException);
|
|
}
|
|
}
|
|
return hadListeners;
|
|
};
|
|
}
|
|
|
|
var originalRetrieveFileHandlers = sharedData.retrieveFileHandlers.slice(0);
|
|
var originalRetrieveMapHandlers = sharedData.retrieveMapHandlers.slice(0);
|
|
|
|
exports.wrapCallSite = wrapCallSite;
|
|
exports.getErrorSource = getErrorSource;
|
|
exports.mapSourcePosition = mapSourcePosition;
|
|
exports.retrieveSourceMap = retrieveSourceMap;
|
|
|
|
exports.install = function(options) {
|
|
options = options || {};
|
|
|
|
if (options.environment) {
|
|
environment = options.environment;
|
|
if (["node", "browser", "auto"].indexOf(environment) === -1) {
|
|
throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}")
|
|
}
|
|
}
|
|
|
|
// Use dynamicRequire to avoid including in browser bundles
|
|
var Module = dynamicRequire(module, 'module');
|
|
|
|
// Redirect subsequent imports of "source-map-support"
|
|
// to this package
|
|
const {redirectConflictingLibrary = true, onConflictingLibraryRedirect} = options;
|
|
if(redirectConflictingLibrary) {
|
|
if (!sharedData.moduleResolveFilenameHook) {
|
|
const originalValue = Module._resolveFilename;
|
|
const moduleResolveFilenameHook = sharedData.moduleResolveFilenameHook = {
|
|
enabled: true,
|
|
originalValue,
|
|
installedValue: undefined,
|
|
}
|
|
Module._resolveFilename = sharedData.moduleResolveFilenameHook.installedValue = function (request, parent, isMain, options) {
|
|
if (moduleResolveFilenameHook.enabled) {
|
|
// Match all source-map-support entrypoints: source-map-support, source-map-support/register
|
|
let requestRedirect;
|
|
if (request === 'source-map-support') {
|
|
requestRedirect = './';
|
|
} else if (request === 'source-map-support/register') {
|
|
requestRedirect = './register';
|
|
}
|
|
|
|
if (requestRedirect !== undefined) {
|
|
const newRequest = require.resolve(requestRedirect);
|
|
for (const cb of sharedData.onConflictingLibraryRedirectArr) {
|
|
cb(request, parent, isMain, options, newRequest);
|
|
}
|
|
request = newRequest;
|
|
}
|
|
}
|
|
|
|
return originalValue.call(this, request, parent, isMain, options);
|
|
}
|
|
}
|
|
if (onConflictingLibraryRedirect) {
|
|
sharedData.onConflictingLibraryRedirectArr.push(onConflictingLibraryRedirect);
|
|
}
|
|
}
|
|
|
|
// Allow sources to be found by methods other than reading the files
|
|
// directly from disk.
|
|
if (options.retrieveFile) {
|
|
if (options.overrideRetrieveFile) {
|
|
sharedData.retrieveFileHandlers.length = 0;
|
|
}
|
|
|
|
sharedData.retrieveFileHandlers.unshift(options.retrieveFile);
|
|
}
|
|
|
|
// Allow source maps to be found by methods other than reading the files
|
|
// directly from disk.
|
|
if (options.retrieveSourceMap) {
|
|
if (options.overrideRetrieveSourceMap) {
|
|
sharedData.retrieveMapHandlers.length = 0;
|
|
}
|
|
|
|
sharedData.retrieveMapHandlers.unshift(options.retrieveSourceMap);
|
|
}
|
|
|
|
// Support runtime transpilers that include inline source maps
|
|
if (options.hookRequire && !isInBrowser()) {
|
|
var $compile = Module.prototype._compile;
|
|
|
|
if (!$compile.__sourceMapSupport) {
|
|
Module.prototype._compile = function(content, filename) {
|
|
setFileContentsCache(filename, content);
|
|
setSourceMapCache(filename, undefined);
|
|
return $compile.call(this, content, filename);
|
|
};
|
|
|
|
Module.prototype._compile.__sourceMapSupport = true;
|
|
}
|
|
}
|
|
|
|
// Configure options
|
|
if (!sharedData.emptyCacheBetweenOperations) {
|
|
sharedData.emptyCacheBetweenOperations = 'emptyCacheBetweenOperations' in options ?
|
|
options.emptyCacheBetweenOperations : false;
|
|
}
|
|
|
|
|
|
// Install the error reformatter
|
|
if (!sharedData.errorPrepareStackTraceHook) {
|
|
const originalValue = Error.prepareStackTrace;
|
|
sharedData.errorPrepareStackTraceHook = {
|
|
enabled: true,
|
|
originalValue,
|
|
installedValue: undefined
|
|
};
|
|
Error.prepareStackTrace = sharedData.errorPrepareStackTraceHook.installedValue = createPrepareStackTrace(sharedData.errorPrepareStackTraceHook);
|
|
}
|
|
|
|
if (!sharedData.processEmitHook) {
|
|
var installHandler = 'handleUncaughtExceptions' in options ?
|
|
options.handleUncaughtExceptions : true;
|
|
|
|
// Do not override 'uncaughtException' with our own handler in Node.js
|
|
// Worker threads. Workers pass the error to the main thread as an event,
|
|
// rather than printing something to stderr and exiting.
|
|
try {
|
|
// We need to use `dynamicRequire` because `require` on it's own will be optimized by WebPack/Browserify.
|
|
var worker_threads = dynamicRequire(module, 'worker_threads');
|
|
if (worker_threads.isMainThread === false) {
|
|
installHandler = false;
|
|
}
|
|
} catch(e) {}
|
|
|
|
// Provide the option to not install the uncaught exception handler. This is
|
|
// to support other uncaught exception handlers (in test frameworks, for
|
|
// example). If this handler is not installed and there are no other uncaught
|
|
// exception handlers, uncaught exceptions will be caught by node's built-in
|
|
// exception handler and the process will still be terminated. However, the
|
|
// generated JavaScript code will be shown above the stack trace instead of
|
|
// the original source code.
|
|
if (installHandler && hasGlobalProcessEventEmitter()) {
|
|
shimEmitUncaughtException();
|
|
}
|
|
}
|
|
};
|
|
|
|
exports.uninstall = function() {
|
|
if(sharedData.processEmitHook) {
|
|
// Disable behavior
|
|
sharedData.processEmitHook.enabled = false;
|
|
// If possible, remove our hook function. May not be possible if subsequent third-party hooks have wrapped around us.
|
|
if(process.emit === sharedData.processEmitHook.installedValue) {
|
|
process.emit = sharedData.processEmitHook.originalValue;
|
|
}
|
|
sharedData.processEmitHook = undefined;
|
|
}
|
|
if(sharedData.errorPrepareStackTraceHook) {
|
|
// Disable behavior
|
|
sharedData.errorPrepareStackTraceHook.enabled = false;
|
|
// If possible or necessary, remove our hook function.
|
|
// In vanilla environments, prepareStackTrace is `undefined`.
|
|
// We cannot delegate to `undefined` the way we can to a function w/`.apply()`; our only option is to remove the function.
|
|
// If we are the *first* hook installed, and another was installed on top of us, we have no choice but to remove both.
|
|
if(Error.prepareStackTrace === sharedData.errorPrepareStackTraceHook.installedValue || typeof sharedData.errorPrepareStackTraceHook.originalValue !== 'function') {
|
|
Error.prepareStackTrace = sharedData.errorPrepareStackTraceHook.originalValue;
|
|
}
|
|
sharedData.errorPrepareStackTraceHook = undefined;
|
|
}
|
|
if (sharedData.moduleResolveFilenameHook) {
|
|
// Disable behavior
|
|
sharedData.moduleResolveFilenameHook.enabled = false;
|
|
// If possible, remove our hook function. May not be possible if subsequent third-party hooks have wrapped around us.
|
|
var Module = dynamicRequire(module, 'module');
|
|
if(Module._resolveFilename === sharedData.moduleResolveFilenameHook.installedValue) {
|
|
Module._resolveFilename = sharedData.moduleResolveFilenameHook.originalValue;
|
|
}
|
|
sharedData.moduleResolveFilenameHook = undefined;
|
|
}
|
|
sharedData.onConflictingLibraryRedirectArr.length = 0;
|
|
}
|
|
|
|
exports.resetRetrieveHandlers = function() {
|
|
sharedData.retrieveFileHandlers.length = 0;
|
|
sharedData.retrieveMapHandlers.length = 0;
|
|
}
|