neo-cmp-cli 1.8.7 → 1.8.8

package/dist/node_modules/source-map-support/source-map-support.js

@@ -0,0 +1,646 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const sourceMapSupport = require('../../_virtual/source-map-support.js');
+const sourceMap = require('../source-map/source-map.js');
+const require$$1 = require('node:path');
+const index = require('../buffer-from/index.js');
+
+sourceMapSupport.__module.exports;
+
+var hasRequiredSourceMapSupport;
+
+function requireSourceMapSupport () {
+	if (hasRequiredSourceMapSupport) return sourceMapSupport.__module.exports;
+	hasRequiredSourceMapSupport = 1;
+	(function (module, exports$1) {
+		var SourceMapConsumer = sourceMap.__require().SourceMapConsumer;
+		var path = require$$1;
+
+		var fs;
+		try {
+		  fs = require('fs');
+		  if (!fs.existsSync || !fs.readFileSync) {
+		    // fs doesn't have all methods we need
+		    fs = null;
+		  }
+		} catch (err) {
+		  /* nop */
+		}
+
+		var bufferFrom = index.__require();
+
+		/**
+		 * Requires a module which is protected against bundler minification.
+		 *
+		 * @param {NodeModule} mod
+		 * @param {string} request
+		 */
+		function dynamicRequire(mod, request) {
+		  return mod.require(request);
+		}
+
+		// Only install once if called multiple times
+		var errorFormatterInstalled = false;
+		var uncaughtShimInstalled = false;
+
+		// If true, the caches are reset before a stack trace formatting operation
+		var emptyCacheBetweenOperations = false;
+
+		// Supports {browser, node, auto}
+		var environment = "auto";
+
+		// Maps a file path to a string containing the file contents
+		var fileContentsCache = {};
+
+		// Maps a file path to a source map for that file
+		var sourceMapCache = {};
+
+		// Regex for detecting source maps
+		var reSourceMap = /^data:application\/json[^,]+base64,/;
+
+		// Priority list of retrieve handlers
+		var retrieveFileHandlers = [];
+		var retrieveMapHandlers = [];
+
+		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 globalProcessVersion() {
+		  if ((typeof process === 'object') && (process !== null)) {
+		    return process.version;
+		  } else {
+		    return '';
+		  }
+		}
+
+		function globalProcessStderr() {
+		  if ((typeof process === 'object') && (process !== null)) {
+		    return process.stderr;
+		  }
+		}
+
+		function globalProcessExit(code) {
+		  if ((typeof process === 'object') && (process !== null) && (typeof process.exit === 'function')) {
+		    return process.exit(code);
+		  }
+		}
+
+		function handlerExec(list) {
+		  return function(arg) {
+		    for (var i = 0; i < list.length; i++) {
+		      var ret = list[i](arg);
+		      if (ret) {
+		        return ret;
+		      }
+		    }
+		    return null;
+		  };
+		}
+
+		var retrieveFile = handlerExec(retrieveFileHandlers);
+
+		retrieveFileHandlers.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
+		    });
+		  }
+		  if (path in fileContentsCache) {
+		    return fileContentsCache[path];
+		  }
+
+		  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 fileContentsCache[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;
+		  var dir = path.dirname(file);
+		  var match = /^\w+:\/\/[^\/]*/.exec(dir);
+		  var protocol = match ? match[0] : '';
+		  var 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);
+		}
+
+		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(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).
+		var retrieveSourceMap = handlerExec(retrieveMapHandlers);
+		retrieveMapHandlers.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 = bufferFrom(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
+		  };
+		});
+
+		function mapSourcePosition(position) {
+		  var sourceMap = sourceMapCache[position.source];
+		  if (!sourceMap) {
+		    // Call the (overrideable) retrieveSourceMap function to get the source map.
+		    var urlAndMap = retrieveSourceMap(position.source);
+		    if (urlAndMap) {
+		      sourceMap = sourceMapCache[position.source] = {
+		        url: urlAndMap.url,
+		        map: new SourceMapConsumer(urlAndMap.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.sourcesContent) {
+		        sourceMap.map.sources.forEach(function(source, i) {
+		          var contents = sourceMap.map.sourcesContent[i];
+		          if (contents) {
+		            var url = supportRelativeURL(sourceMap.url, source);
+		            fileContentsCache[url] = contents;
+		          }
+		        });
+		      }
+		    } else {
+		      sourceMap = sourceMapCache[position.source] = {
+		        url: null,
+		        map: null
+		      };
+		    }
+		  }
+
+		  // Resolve the source URL relative to the URL of the source map
+		  if (sourceMap && sourceMap.map && typeof sourceMap.map.originalPositionFor === 'function') {
+		    var originalPosition = sourceMap.map.originalPositionFor(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 = supportRelativeURL(
+		        sourceMap.url, 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. 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 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) {
+		    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(globalProcessVersion()) ? 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;
+		}
+
+		// 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 (emptyCacheBetweenOperations) {
+		    fileContentsCache = {};
+		    sourceMapCache = {};
+		  }
+
+		  var name = error.name || 'Error';
+		  var message = error.message || '';
+		  var errorString = name + ": " + message;
+
+		  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 = fileContentsCache[source];
+
+		    // Support files on disk
+		    if (!contents && fs && fs.existsSync(source)) {
+		      try {
+		        contents = fs.readFileSync(source, '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 printErrorAndExit (error) {
+		  var source = getErrorSource(error);
+
+		  // Ensure error is printed synchronously and not truncated
+		  var stderr = globalProcessStderr();
+		  if (stderr && stderr._handle && stderr._handle.setBlocking) {
+		    stderr._handle.setBlocking(true);
+		  }
+
+		  if (source) {
+		    console.error();
+		    console.error(source);
+		  }
+
+		  console.error(error.stack);
+		  globalProcessExit(1);
+		}
+
+		function shimEmitUncaughtException () {
+		  var origEmit = process.emit;
+
+		  process.emit = function (type) {
+		    if (type === 'uncaughtException') {
+		      var hasStack = (arguments[1] && arguments[1].stack);
+		      var hasListeners = (this.listeners(type).length > 0);
+
+		      if (hasStack && !hasListeners) {
+		        return printErrorAndExit(arguments[1]);
+		      }
+		    }
+
+		    return origEmit.apply(this, arguments);
+		  };
+		}
+
+		var originalRetrieveFileHandlers = retrieveFileHandlers.slice(0);
+		var originalRetrieveMapHandlers = retrieveMapHandlers.slice(0);
+
+		exports$1.wrapCallSite = wrapCallSite;
+		exports$1.getErrorSource = getErrorSource;
+		exports$1.mapSourcePosition = mapSourcePosition;
+		exports$1.retrieveSourceMap = retrieveSourceMap;
+
+		exports$1.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}")
+		    }
+		  }
+
+		  // Allow sources to be found by methods other than reading the files
+		  // directly from disk.
+		  if (options.retrieveFile) {
+		    if (options.overrideRetrieveFile) {
+		      retrieveFileHandlers.length = 0;
+		    }
+
+		    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) {
+		      retrieveMapHandlers.length = 0;
+		    }
+
+		    retrieveMapHandlers.unshift(options.retrieveSourceMap);
+		  }
+
+		  // Support runtime transpilers that include inline source maps
+		  if (options.hookRequire && !isInBrowser()) {
+		    // Use dynamicRequire to avoid including in browser bundles
+		    var Module = dynamicRequire(module, 'module');
+		    var $compile = Module.prototype._compile;
+
+		    if (!$compile.__sourceMapSupport) {
+		      Module.prototype._compile = function(content, filename) {
+		        fileContentsCache[filename] = content;
+		        sourceMapCache[filename] = undefined;
+		        return $compile.call(this, content, filename);
+		      };
+
+		      Module.prototype._compile.__sourceMapSupport = true;
+		    }
+		  }
+
+		  // Configure options
+		  if (!emptyCacheBetweenOperations) {
+		    emptyCacheBetweenOperations = 'emptyCacheBetweenOperations' in options ?
+		      options.emptyCacheBetweenOperations : false;
+		  }
+
+		  // Install the error reformatter
+		  if (!errorFormatterInstalled) {
+		    errorFormatterInstalled = true;
+		    Error.prepareStackTrace = prepareStackTrace;
+		  }
+
+		  if (!uncaughtShimInstalled) {
+		    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()) {
+		      uncaughtShimInstalled = true;
+		      shimEmitUncaughtException();
+		    }
+		  }
+		};
+
+		exports$1.resetRetrieveHandlers = function() {
+		  retrieveFileHandlers.length = 0;
+		  retrieveMapHandlers.length = 0;
+
+		  retrieveFileHandlers = originalRetrieveFileHandlers.slice(0);
+		  retrieveMapHandlers = originalRetrieveMapHandlers.slice(0);
+
+		  retrieveSourceMap = handlerExec(retrieveMapHandlers);
+		  retrieveFile = handlerExec(retrieveFileHandlers);
+		}; 
+	} (sourceMapSupport.__module, sourceMapSupport.__module.exports));
+	return sourceMapSupport.__module.exports;
+}
+
+exports.__require = requireSourceMapSupport;