snyk 1.1286.0 → 1.1286.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -25716,7 +25716,7 @@ module.exports = compare
25716
25716
 
25717
25717
  /***/ }),
25718
25718
 
25719
- /***/ 66483:
25719
+ /***/ 77094:
25720
25720
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
25721
25721
 
25722
25722
  const parse = __webpack_require__(80670)
@@ -26012,7 +26012,7 @@ const parse = __webpack_require__(80670)
26012
26012
  const valid = __webpack_require__(8691)
26013
26013
  const clean = __webpack_require__(39617)
26014
26014
  const inc = __webpack_require__(9257)
26015
- const diff = __webpack_require__(66483)
26015
+ const diff = __webpack_require__(77094)
26016
26016
  const major = __webpack_require__(12879)
26017
26017
  const minor = __webpack_require__(91362)
26018
26018
  const patch = __webpack_require__(41067)
@@ -244602,6 +244602,8 @@ function buildArgs(sbtArgs, isCoursierProject, isOutputGraph) {
244602
244602
  args.push('coursierDependencyTree'); // coursier
244603
244603
  }
244604
244604
  else {
244605
+ // enhance sbt default output width from 40 chars to the max
244606
+ args.push('set asciiGraphWidth := 999999999');
244605
244607
  args.push('dependencyTree'); // sbt native
244606
244608
  }
244607
244609
  return args;
@@ -246102,7 +246104,648 @@ exports.execute = execute;
246102
246104
 
246103
246105
  /***/ }),
246104
246106
 
246105
- /***/ 2937:
246107
+ /***/ 20406:
246108
+ /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
246109
+
246110
+ __webpack_require__(76252).install();
246111
+
246112
+
246113
+ /***/ }),
246114
+
246115
+ /***/ 76252:
246116
+ /***/ ((module, exports, __webpack_require__) => {
246117
+
246118
+ /* module decorator */ module = __webpack_require__.nmd(module);
246119
+ var SourceMapConsumer = __webpack_require__(49125).SourceMapConsumer;
246120
+ var path = __webpack_require__(71017);
246121
+
246122
+ var fs;
246123
+ try {
246124
+ fs = __webpack_require__(57147);
246125
+ if (!fs.existsSync || !fs.readFileSync) {
246126
+ // fs doesn't have all methods we need
246127
+ fs = null;
246128
+ }
246129
+ } catch (err) {
246130
+ /* nop */
246131
+ }
246132
+
246133
+ var bufferFrom = __webpack_require__(55420);
246134
+
246135
+ /**
246136
+ * Requires a module which is protected against bundler minification.
246137
+ *
246138
+ * @param {NodeModule} mod
246139
+ * @param {string} request
246140
+ */
246141
+ function dynamicRequire(mod, request) {
246142
+ return mod.require(request);
246143
+ }
246144
+
246145
+ // Only install once if called multiple times
246146
+ var errorFormatterInstalled = false;
246147
+ var uncaughtShimInstalled = false;
246148
+
246149
+ // If true, the caches are reset before a stack trace formatting operation
246150
+ var emptyCacheBetweenOperations = false;
246151
+
246152
+ // Supports {browser, node, auto}
246153
+ var environment = "auto";
246154
+
246155
+ // Maps a file path to a string containing the file contents
246156
+ var fileContentsCache = {};
246157
+
246158
+ // Maps a file path to a source map for that file
246159
+ var sourceMapCache = {};
246160
+
246161
+ // Regex for detecting source maps
246162
+ var reSourceMap = /^data:application\/json[^,]+base64,/;
246163
+
246164
+ // Priority list of retrieve handlers
246165
+ var retrieveFileHandlers = [];
246166
+ var retrieveMapHandlers = [];
246167
+
246168
+ function isInBrowser() {
246169
+ if (environment === "browser")
246170
+ return true;
246171
+ if (environment === "node")
246172
+ return false;
246173
+ return ((typeof window !== 'undefined') && (typeof XMLHttpRequest === 'function') && !(window.require && window.module && window.process && window.process.type === "renderer"));
246174
+ }
246175
+
246176
+ function hasGlobalProcessEventEmitter() {
246177
+ return ((typeof process === 'object') && (process !== null) && (typeof process.on === 'function'));
246178
+ }
246179
+
246180
+ function globalProcessVersion() {
246181
+ if ((typeof process === 'object') && (process !== null)) {
246182
+ return process.version;
246183
+ } else {
246184
+ return '';
246185
+ }
246186
+ }
246187
+
246188
+ function globalProcessStderr() {
246189
+ if ((typeof process === 'object') && (process !== null)) {
246190
+ return process.stderr;
246191
+ }
246192
+ }
246193
+
246194
+ function globalProcessExit(code) {
246195
+ if ((typeof process === 'object') && (process !== null) && (typeof process.exit === 'function')) {
246196
+ return process.exit(code);
246197
+ }
246198
+ }
246199
+
246200
+ function handlerExec(list) {
246201
+ return function(arg) {
246202
+ for (var i = 0; i < list.length; i++) {
246203
+ var ret = list[i](arg);
246204
+ if (ret) {
246205
+ return ret;
246206
+ }
246207
+ }
246208
+ return null;
246209
+ };
246210
+ }
246211
+
246212
+ var retrieveFile = handlerExec(retrieveFileHandlers);
246213
+
246214
+ retrieveFileHandlers.push(function(path) {
246215
+ // Trim the path to make sure there is no extra whitespace.
246216
+ path = path.trim();
246217
+ if (/^file:/.test(path)) {
246218
+ // existsSync/readFileSync can't handle file protocol, but once stripped, it works
246219
+ path = path.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
246220
+ return drive ?
246221
+ '' : // file:///C:/dir/file -> C:/dir/file
246222
+ '/'; // file:///root-dir/file -> /root-dir/file
246223
+ });
246224
+ }
246225
+ if (path in fileContentsCache) {
246226
+ return fileContentsCache[path];
246227
+ }
246228
+
246229
+ var contents = '';
246230
+ try {
246231
+ if (!fs) {
246232
+ // Use SJAX if we are in the browser
246233
+ var xhr = new XMLHttpRequest();
246234
+ xhr.open('GET', path, /** async */ false);
246235
+ xhr.send(null);
246236
+ if (xhr.readyState === 4 && xhr.status === 200) {
246237
+ contents = xhr.responseText;
246238
+ }
246239
+ } else if (fs.existsSync(path)) {
246240
+ // Otherwise, use the filesystem
246241
+ contents = fs.readFileSync(path, 'utf8');
246242
+ }
246243
+ } catch (er) {
246244
+ /* ignore any errors */
246245
+ }
246246
+
246247
+ return fileContentsCache[path] = contents;
246248
+ });
246249
+
246250
+ // Support URLs relative to a directory, but be careful about a protocol prefix
246251
+ // in case we are in the browser (i.e. directories may start with "http://" or "file:///")
246252
+ function supportRelativeURL(file, url) {
246253
+ if (!file) return url;
246254
+ var dir = path.dirname(file);
246255
+ var match = /^\w+:\/\/[^\/]*/.exec(dir);
246256
+ var protocol = match ? match[0] : '';
246257
+ var startPath = dir.slice(protocol.length);
246258
+ if (protocol && /^\/\w\:/.test(startPath)) {
246259
+ // handle file:///C:/ paths
246260
+ protocol += '/';
246261
+ return protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, '/');
246262
+ }
246263
+ return protocol + path.resolve(dir.slice(protocol.length), url);
246264
+ }
246265
+
246266
+ function retrieveSourceMapURL(source) {
246267
+ var fileData;
246268
+
246269
+ if (isInBrowser()) {
246270
+ try {
246271
+ var xhr = new XMLHttpRequest();
246272
+ xhr.open('GET', source, false);
246273
+ xhr.send(null);
246274
+ fileData = xhr.readyState === 4 ? xhr.responseText : null;
246275
+
246276
+ // Support providing a sourceMappingURL via the SourceMap header
246277
+ var sourceMapHeader = xhr.getResponseHeader("SourceMap") ||
246278
+ xhr.getResponseHeader("X-SourceMap");
246279
+ if (sourceMapHeader) {
246280
+ return sourceMapHeader;
246281
+ }
246282
+ } catch (e) {
246283
+ }
246284
+ }
246285
+
246286
+ // Get the URL of the source map
246287
+ fileData = retrieveFile(source);
246288
+ var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;
246289
+ // Keep executing the search to find the *last* sourceMappingURL to avoid
246290
+ // picking up sourceMappingURLs from comments, strings, etc.
246291
+ var lastMatch, match;
246292
+ while (match = re.exec(fileData)) lastMatch = match;
246293
+ if (!lastMatch) return null;
246294
+ return lastMatch[1];
246295
+ };
246296
+
246297
+ // Can be overridden by the retrieveSourceMap option to install. Takes a
246298
+ // generated source filename; returns a {map, optional url} object, or null if
246299
+ // there is no source map. The map field may be either a string or the parsed
246300
+ // JSON object (ie, it must be a valid argument to the SourceMapConsumer
246301
+ // constructor).
246302
+ var retrieveSourceMap = handlerExec(retrieveMapHandlers);
246303
+ retrieveMapHandlers.push(function(source) {
246304
+ var sourceMappingURL = retrieveSourceMapURL(source);
246305
+ if (!sourceMappingURL) return null;
246306
+
246307
+ // Read the contents of the source map
246308
+ var sourceMapData;
246309
+ if (reSourceMap.test(sourceMappingURL)) {
246310
+ // Support source map URL as a data url
246311
+ var rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(',') + 1);
246312
+ sourceMapData = bufferFrom(rawData, "base64").toString();
246313
+ sourceMappingURL = source;
246314
+ } else {
246315
+ // Support source map URLs relative to the source URL
246316
+ sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
246317
+ sourceMapData = retrieveFile(sourceMappingURL);
246318
+ }
246319
+
246320
+ if (!sourceMapData) {
246321
+ return null;
246322
+ }
246323
+
246324
+ return {
246325
+ url: sourceMappingURL,
246326
+ map: sourceMapData
246327
+ };
246328
+ });
246329
+
246330
+ function mapSourcePosition(position) {
246331
+ var sourceMap = sourceMapCache[position.source];
246332
+ if (!sourceMap) {
246333
+ // Call the (overrideable) retrieveSourceMap function to get the source map.
246334
+ var urlAndMap = retrieveSourceMap(position.source);
246335
+ if (urlAndMap) {
246336
+ sourceMap = sourceMapCache[position.source] = {
246337
+ url: urlAndMap.url,
246338
+ map: new SourceMapConsumer(urlAndMap.map)
246339
+ };
246340
+
246341
+ // Load all sources stored inline with the source map into the file cache
246342
+ // to pretend like they are already loaded. They may not exist on disk.
246343
+ if (sourceMap.map.sourcesContent) {
246344
+ sourceMap.map.sources.forEach(function(source, i) {
246345
+ var contents = sourceMap.map.sourcesContent[i];
246346
+ if (contents) {
246347
+ var url = supportRelativeURL(sourceMap.url, source);
246348
+ fileContentsCache[url] = contents;
246349
+ }
246350
+ });
246351
+ }
246352
+ } else {
246353
+ sourceMap = sourceMapCache[position.source] = {
246354
+ url: null,
246355
+ map: null
246356
+ };
246357
+ }
246358
+ }
246359
+
246360
+ // Resolve the source URL relative to the URL of the source map
246361
+ if (sourceMap && sourceMap.map && typeof sourceMap.map.originalPositionFor === 'function') {
246362
+ var originalPosition = sourceMap.map.originalPositionFor(position);
246363
+
246364
+ // Only return the original position if a matching line was found. If no
246365
+ // matching line is found then we return position instead, which will cause
246366
+ // the stack trace to print the path and line for the compiled file. It is
246367
+ // better to give a precise location in the compiled file than a vague
246368
+ // location in the original file.
246369
+ if (originalPosition.source !== null) {
246370
+ originalPosition.source = supportRelativeURL(
246371
+ sourceMap.url, originalPosition.source);
246372
+ return originalPosition;
246373
+ }
246374
+ }
246375
+
246376
+ return position;
246377
+ }
246378
+
246379
+ // Parses code generated by FormatEvalOrigin(), a function inside V8:
246380
+ // https://code.google.com/p/v8/source/browse/trunk/src/messages.js
246381
+ function mapEvalOrigin(origin) {
246382
+ // Most eval() calls are in this format
246383
+ var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
246384
+ if (match) {
246385
+ var position = mapSourcePosition({
246386
+ source: match[2],
246387
+ line: +match[3],
246388
+ column: match[4] - 1
246389
+ });
246390
+ return 'eval at ' + match[1] + ' (' + position.source + ':' +
246391
+ position.line + ':' + (position.column + 1) + ')';
246392
+ }
246393
+
246394
+ // Parse nested eval() calls using recursion
246395
+ match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
246396
+ if (match) {
246397
+ return 'eval at ' + match[1] + ' (' + mapEvalOrigin(match[2]) + ')';
246398
+ }
246399
+
246400
+ // Make sure we still return useful information if we didn't find anything
246401
+ return origin;
246402
+ }
246403
+
246404
+ // This is copied almost verbatim from the V8 source code at
246405
+ // https://code.google.com/p/v8/source/browse/trunk/src/messages.js. The
246406
+ // implementation of wrapCallSite() used to just forward to the actual source
246407
+ // code of CallSite.prototype.toString but unfortunately a new release of V8
246408
+ // did something to the prototype chain and broke the shim. The only fix I
246409
+ // could find was copy/paste.
246410
+ function CallSiteToString() {
246411
+ var fileName;
246412
+ var fileLocation = "";
246413
+ if (this.isNative()) {
246414
+ fileLocation = "native";
246415
+ } else {
246416
+ fileName = this.getScriptNameOrSourceURL();
246417
+ if (!fileName && this.isEval()) {
246418
+ fileLocation = this.getEvalOrigin();
246419
+ fileLocation += ", "; // Expecting source position to follow.
246420
+ }
246421
+
246422
+ if (fileName) {
246423
+ fileLocation += fileName;
246424
+ } else {
246425
+ // Source code does not originate from a file and is not native, but we
246426
+ // can still get the source position inside the source string, e.g. in
246427
+ // an eval string.
246428
+ fileLocation += "<anonymous>";
246429
+ }
246430
+ var lineNumber = this.getLineNumber();
246431
+ if (lineNumber != null) {
246432
+ fileLocation += ":" + lineNumber;
246433
+ var columnNumber = this.getColumnNumber();
246434
+ if (columnNumber) {
246435
+ fileLocation += ":" + columnNumber;
246436
+ }
246437
+ }
246438
+ }
246439
+
246440
+ var line = "";
246441
+ var functionName = this.getFunctionName();
246442
+ var addSuffix = true;
246443
+ var isConstructor = this.isConstructor();
246444
+ var isMethodCall = !(this.isToplevel() || isConstructor);
246445
+ if (isMethodCall) {
246446
+ var typeName = this.getTypeName();
246447
+ // Fixes shim to be backward compatable with Node v0 to v4
246448
+ if (typeName === "[object Object]") {
246449
+ typeName = "null";
246450
+ }
246451
+ var methodName = this.getMethodName();
246452
+ if (functionName) {
246453
+ if (typeName && functionName.indexOf(typeName) != 0) {
246454
+ line += typeName + ".";
246455
+ }
246456
+ line += functionName;
246457
+ if (methodName && functionName.indexOf("." + methodName) != functionName.length - methodName.length - 1) {
246458
+ line += " [as " + methodName + "]";
246459
+ }
246460
+ } else {
246461
+ line += typeName + "." + (methodName || "<anonymous>");
246462
+ }
246463
+ } else if (isConstructor) {
246464
+ line += "new " + (functionName || "<anonymous>");
246465
+ } else if (functionName) {
246466
+ line += functionName;
246467
+ } else {
246468
+ line += fileLocation;
246469
+ addSuffix = false;
246470
+ }
246471
+ if (addSuffix) {
246472
+ line += " (" + fileLocation + ")";
246473
+ }
246474
+ return line;
246475
+ }
246476
+
246477
+ function cloneCallSite(frame) {
246478
+ var object = {};
246479
+ Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function(name) {
246480
+ object[name] = /^(?:is|get)/.test(name) ? function() { return frame[name].call(frame); } : frame[name];
246481
+ });
246482
+ object.toString = CallSiteToString;
246483
+ return object;
246484
+ }
246485
+
246486
+ function wrapCallSite(frame, state) {
246487
+ // provides interface backward compatibility
246488
+ if (state === undefined) {
246489
+ state = { nextPosition: null, curPosition: null }
246490
+ }
246491
+ if(frame.isNative()) {
246492
+ state.curPosition = null;
246493
+ return frame;
246494
+ }
246495
+
246496
+ // Most call sites will return the source file from getFileName(), but code
246497
+ // passed to eval() ending in "//# sourceURL=..." will return the source file
246498
+ // from getScriptNameOrSourceURL() instead
246499
+ var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
246500
+ if (source) {
246501
+ var line = frame.getLineNumber();
246502
+ var column = frame.getColumnNumber() - 1;
246503
+
246504
+ // Fix position in Node where some (internal) code is prepended.
246505
+ // See https://github.com/evanw/node-source-map-support/issues/36
246506
+ // Header removed in node at ^10.16 || >=11.11.0
246507
+ // v11 is not an LTS candidate, we can just test the one version with it.
246508
+ // Test node versions for: 10.16-19, 10.20+, 12-19, 20-99, 100+, or 11.11
246509
+ 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)/;
246510
+ var headerLength = noHeader.test(globalProcessVersion()) ? 0 : 62;
246511
+ if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) {
246512
+ column -= headerLength;
246513
+ }
246514
+
246515
+ var position = mapSourcePosition({
246516
+ source: source,
246517
+ line: line,
246518
+ column: column
246519
+ });
246520
+ state.curPosition = position;
246521
+ frame = cloneCallSite(frame);
246522
+ var originalFunctionName = frame.getFunctionName;
246523
+ frame.getFunctionName = function() {
246524
+ if (state.nextPosition == null) {
246525
+ return originalFunctionName();
246526
+ }
246527
+ return state.nextPosition.name || originalFunctionName();
246528
+ };
246529
+ frame.getFileName = function() { return position.source; };
246530
+ frame.getLineNumber = function() { return position.line; };
246531
+ frame.getColumnNumber = function() { return position.column + 1; };
246532
+ frame.getScriptNameOrSourceURL = function() { return position.source; };
246533
+ return frame;
246534
+ }
246535
+
246536
+ // Code called using eval() needs special handling
246537
+ var origin = frame.isEval() && frame.getEvalOrigin();
246538
+ if (origin) {
246539
+ origin = mapEvalOrigin(origin);
246540
+ frame = cloneCallSite(frame);
246541
+ frame.getEvalOrigin = function() { return origin; };
246542
+ return frame;
246543
+ }
246544
+
246545
+ // If we get here then we were unable to change the source position
246546
+ return frame;
246547
+ }
246548
+
246549
+ // This function is part of the V8 stack trace API, for more info see:
246550
+ // https://v8.dev/docs/stack-trace-api
246551
+ function prepareStackTrace(error, stack) {
246552
+ if (emptyCacheBetweenOperations) {
246553
+ fileContentsCache = {};
246554
+ sourceMapCache = {};
246555
+ }
246556
+
246557
+ var name = error.name || 'Error';
246558
+ var message = error.message || '';
246559
+ var errorString = name + ": " + message;
246560
+
246561
+ var state = { nextPosition: null, curPosition: null };
246562
+ var processedStack = [];
246563
+ for (var i = stack.length - 1; i >= 0; i--) {
246564
+ processedStack.push('\n at ' + wrapCallSite(stack[i], state));
246565
+ state.nextPosition = state.curPosition;
246566
+ }
246567
+ state.curPosition = state.nextPosition = null;
246568
+ return errorString + processedStack.reverse().join('');
246569
+ }
246570
+
246571
+ // Generate position and snippet of original source with pointer
246572
+ function getErrorSource(error) {
246573
+ var match = /\n at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
246574
+ if (match) {
246575
+ var source = match[1];
246576
+ var line = +match[2];
246577
+ var column = +match[3];
246578
+
246579
+ // Support the inline sourceContents inside the source map
246580
+ var contents = fileContentsCache[source];
246581
+
246582
+ // Support files on disk
246583
+ if (!contents && fs && fs.existsSync(source)) {
246584
+ try {
246585
+ contents = fs.readFileSync(source, 'utf8');
246586
+ } catch (er) {
246587
+ contents = '';
246588
+ }
246589
+ }
246590
+
246591
+ // Format the line from the original source code like node does
246592
+ if (contents) {
246593
+ var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
246594
+ if (code) {
246595
+ return source + ':' + line + '\n' + code + '\n' +
246596
+ new Array(column).join(' ') + '^';
246597
+ }
246598
+ }
246599
+ }
246600
+ return null;
246601
+ }
246602
+
246603
+ function printErrorAndExit (error) {
246604
+ var source = getErrorSource(error);
246605
+
246606
+ // Ensure error is printed synchronously and not truncated
246607
+ var stderr = globalProcessStderr();
246608
+ if (stderr && stderr._handle && stderr._handle.setBlocking) {
246609
+ stderr._handle.setBlocking(true);
246610
+ }
246611
+
246612
+ if (source) {
246613
+ console.error();
246614
+ console.error(source);
246615
+ }
246616
+
246617
+ console.error(error.stack);
246618
+ globalProcessExit(1);
246619
+ }
246620
+
246621
+ function shimEmitUncaughtException () {
246622
+ var origEmit = process.emit;
246623
+
246624
+ process.emit = function (type) {
246625
+ if (type === 'uncaughtException') {
246626
+ var hasStack = (arguments[1] && arguments[1].stack);
246627
+ var hasListeners = (this.listeners(type).length > 0);
246628
+
246629
+ if (hasStack && !hasListeners) {
246630
+ return printErrorAndExit(arguments[1]);
246631
+ }
246632
+ }
246633
+
246634
+ return origEmit.apply(this, arguments);
246635
+ };
246636
+ }
246637
+
246638
+ var originalRetrieveFileHandlers = retrieveFileHandlers.slice(0);
246639
+ var originalRetrieveMapHandlers = retrieveMapHandlers.slice(0);
246640
+
246641
+ exports.wrapCallSite = wrapCallSite;
246642
+ exports.getErrorSource = getErrorSource;
246643
+ exports.mapSourcePosition = mapSourcePosition;
246644
+ exports.retrieveSourceMap = retrieveSourceMap;
246645
+
246646
+ exports.install = function(options) {
246647
+ options = options || {};
246648
+
246649
+ if (options.environment) {
246650
+ environment = options.environment;
246651
+ if (["node", "browser", "auto"].indexOf(environment) === -1) {
246652
+ throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}")
246653
+ }
246654
+ }
246655
+
246656
+ // Allow sources to be found by methods other than reading the files
246657
+ // directly from disk.
246658
+ if (options.retrieveFile) {
246659
+ if (options.overrideRetrieveFile) {
246660
+ retrieveFileHandlers.length = 0;
246661
+ }
246662
+
246663
+ retrieveFileHandlers.unshift(options.retrieveFile);
246664
+ }
246665
+
246666
+ // Allow source maps to be found by methods other than reading the files
246667
+ // directly from disk.
246668
+ if (options.retrieveSourceMap) {
246669
+ if (options.overrideRetrieveSourceMap) {
246670
+ retrieveMapHandlers.length = 0;
246671
+ }
246672
+
246673
+ retrieveMapHandlers.unshift(options.retrieveSourceMap);
246674
+ }
246675
+
246676
+ // Support runtime transpilers that include inline source maps
246677
+ if (options.hookRequire && !isInBrowser()) {
246678
+ // Use dynamicRequire to avoid including in browser bundles
246679
+ var Module = dynamicRequire(module, 'module');
246680
+ var $compile = Module.prototype._compile;
246681
+
246682
+ if (!$compile.__sourceMapSupport) {
246683
+ Module.prototype._compile = function(content, filename) {
246684
+ fileContentsCache[filename] = content;
246685
+ sourceMapCache[filename] = undefined;
246686
+ return $compile.call(this, content, filename);
246687
+ };
246688
+
246689
+ Module.prototype._compile.__sourceMapSupport = true;
246690
+ }
246691
+ }
246692
+
246693
+ // Configure options
246694
+ if (!emptyCacheBetweenOperations) {
246695
+ emptyCacheBetweenOperations = 'emptyCacheBetweenOperations' in options ?
246696
+ options.emptyCacheBetweenOperations : false;
246697
+ }
246698
+
246699
+ // Install the error reformatter
246700
+ if (!errorFormatterInstalled) {
246701
+ errorFormatterInstalled = true;
246702
+ Error.prepareStackTrace = prepareStackTrace;
246703
+ }
246704
+
246705
+ if (!uncaughtShimInstalled) {
246706
+ var installHandler = 'handleUncaughtExceptions' in options ?
246707
+ options.handleUncaughtExceptions : true;
246708
+
246709
+ // Do not override 'uncaughtException' with our own handler in Node.js
246710
+ // Worker threads. Workers pass the error to the main thread as an event,
246711
+ // rather than printing something to stderr and exiting.
246712
+ try {
246713
+ // We need to use `dynamicRequire` because `require` on it's own will be optimized by WebPack/Browserify.
246714
+ var worker_threads = dynamicRequire(module, 'worker_threads');
246715
+ if (worker_threads.isMainThread === false) {
246716
+ installHandler = false;
246717
+ }
246718
+ } catch(e) {}
246719
+
246720
+ // Provide the option to not install the uncaught exception handler. This is
246721
+ // to support other uncaught exception handlers (in test frameworks, for
246722
+ // example). If this handler is not installed and there are no other uncaught
246723
+ // exception handlers, uncaught exceptions will be caught by node's built-in
246724
+ // exception handler and the process will still be terminated. However, the
246725
+ // generated JavaScript code will be shown above the stack trace instead of
246726
+ // the original source code.
246727
+ if (installHandler && hasGlobalProcessEventEmitter()) {
246728
+ uncaughtShimInstalled = true;
246729
+ shimEmitUncaughtException();
246730
+ }
246731
+ }
246732
+ };
246733
+
246734
+ exports.resetRetrieveHandlers = function() {
246735
+ retrieveFileHandlers.length = 0;
246736
+ retrieveMapHandlers.length = 0;
246737
+
246738
+ retrieveFileHandlers = originalRetrieveFileHandlers.slice(0);
246739
+ retrieveMapHandlers = originalRetrieveMapHandlers.slice(0);
246740
+
246741
+ retrieveSourceMap = handlerExec(retrieveMapHandlers);
246742
+ retrieveFile = handlerExec(retrieveFileHandlers);
246743
+ }
246744
+
246745
+
246746
+ /***/ }),
246747
+
246748
+ /***/ 78213:
246106
246749
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
246107
246750
 
246108
246751
  /* -*- Mode: js; js-indent-level: 2; -*- */
@@ -246112,7 +246755,7 @@ exports.execute = execute;
246112
246755
  * http://opensource.org/licenses/BSD-3-Clause
246113
246756
  */
246114
246757
 
246115
- var util = __webpack_require__(5454);
246758
+ var util = __webpack_require__(32728);
246116
246759
  var has = Object.prototype.hasOwnProperty;
246117
246760
  var hasNativeMap = typeof Map !== "undefined";
246118
246761
 
@@ -246230,7 +246873,7 @@ exports.I = ArraySet;
246230
246873
 
246231
246874
  /***/ }),
246232
246875
 
246233
- /***/ 41503:
246876
+ /***/ 16400:
246234
246877
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
246235
246878
 
246236
246879
  /* -*- Mode: js; js-indent-level: 2; -*- */
@@ -246270,7 +246913,7 @@ exports.I = ArraySet;
246270
246913
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
246271
246914
  */
246272
246915
 
246273
- var base64 = __webpack_require__(28256);
246916
+ var base64 = __webpack_require__(67923);
246274
246917
 
246275
246918
  // A single base 64 digit can contain 6 bits of data. For the base 64 variable
246276
246919
  // length quantities we use in the source map spec, the first bit is the sign,
@@ -246377,7 +247020,7 @@ exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
246377
247020
 
246378
247021
  /***/ }),
246379
247022
 
246380
- /***/ 28256:
247023
+ /***/ 67923:
246381
247024
  /***/ ((__unused_webpack_module, exports) => {
246382
247025
 
246383
247026
  /* -*- Mode: js; js-indent-level: 2; -*- */
@@ -246451,7 +247094,7 @@ exports.decode = function (charCode) {
246451
247094
 
246452
247095
  /***/ }),
246453
247096
 
246454
- /***/ 69240:
247097
+ /***/ 9216:
246455
247098
  /***/ ((__unused_webpack_module, exports) => {
246456
247099
 
246457
247100
  /* -*- Mode: js; js-indent-level: 2; -*- */
@@ -246569,7 +247212,7 @@ exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
246569
247212
 
246570
247213
  /***/ }),
246571
247214
 
246572
- /***/ 47524:
247215
+ /***/ 21188:
246573
247216
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
246574
247217
 
246575
247218
  /* -*- Mode: js; js-indent-level: 2; -*- */
@@ -246579,7 +247222,7 @@ exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
246579
247222
  * http://opensource.org/licenses/BSD-3-Clause
246580
247223
  */
246581
247224
 
246582
- var util = __webpack_require__(5454);
247225
+ var util = __webpack_require__(32728);
246583
247226
 
246584
247227
  /**
246585
247228
  * Determine whether mappingB is after mappingA with respect to generated
@@ -246655,7 +247298,7 @@ exports.H = MappingList;
246655
247298
 
246656
247299
  /***/ }),
246657
247300
 
246658
- /***/ 77094:
247301
+ /***/ 22826:
246659
247302
  /***/ ((__unused_webpack_module, exports) => {
246660
247303
 
246661
247304
  /* -*- Mode: js; js-indent-level: 2; -*- */
@@ -246776,7 +247419,7 @@ exports.U = function (ary, comparator) {
246776
247419
 
246777
247420
  /***/ }),
246778
247421
 
246779
- /***/ 66913:
247422
+ /***/ 76771:
246780
247423
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
246781
247424
 
246782
247425
  var __webpack_unused_export__;
@@ -246787,11 +247430,11 @@ var __webpack_unused_export__;
246787
247430
  * http://opensource.org/licenses/BSD-3-Clause
246788
247431
  */
246789
247432
 
246790
- var util = __webpack_require__(5454);
246791
- var binarySearch = __webpack_require__(69240);
246792
- var ArraySet = __webpack_require__(2937)/* .ArraySet */ .I;
246793
- var base64VLQ = __webpack_require__(41503);
246794
- var quickSort = __webpack_require__(77094)/* .quickSort */ .U;
247433
+ var util = __webpack_require__(32728);
247434
+ var binarySearch = __webpack_require__(9216);
247435
+ var ArraySet = __webpack_require__(78213)/* .ArraySet */ .I;
247436
+ var base64VLQ = __webpack_require__(16400);
247437
+ var quickSort = __webpack_require__(22826)/* .quickSort */ .U;
246795
247438
 
246796
247439
  function SourceMapConsumer(aSourceMap, aSourceMapURL) {
246797
247440
  var sourceMap = aSourceMap;
@@ -247929,7 +248572,7 @@ __webpack_unused_export__ = IndexedSourceMapConsumer;
247929
248572
 
247930
248573
  /***/ }),
247931
248574
 
247932
- /***/ 1880:
248575
+ /***/ 34433:
247933
248576
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
247934
248577
 
247935
248578
  /* -*- Mode: js; js-indent-level: 2; -*- */
@@ -247939,10 +248582,10 @@ __webpack_unused_export__ = IndexedSourceMapConsumer;
247939
248582
  * http://opensource.org/licenses/BSD-3-Clause
247940
248583
  */
247941
248584
 
247942
- var base64VLQ = __webpack_require__(41503);
247943
- var util = __webpack_require__(5454);
247944
- var ArraySet = __webpack_require__(2937)/* .ArraySet */ .I;
247945
- var MappingList = __webpack_require__(47524)/* .MappingList */ .H;
248585
+ var base64VLQ = __webpack_require__(16400);
248586
+ var util = __webpack_require__(32728);
248587
+ var ArraySet = __webpack_require__(78213)/* .ArraySet */ .I;
248588
+ var MappingList = __webpack_require__(21188)/* .MappingList */ .H;
247946
248589
 
247947
248590
  /**
247948
248591
  * An instance of the SourceMapGenerator represents a source map which is
@@ -248361,7 +249004,7 @@ exports.h = SourceMapGenerator;
248361
249004
 
248362
249005
  /***/ }),
248363
249006
 
248364
- /***/ 95121:
249007
+ /***/ 17085:
248365
249008
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
248366
249009
 
248367
249010
  var __webpack_unused_export__;
@@ -248372,8 +249015,8 @@ var __webpack_unused_export__;
248372
249015
  * http://opensource.org/licenses/BSD-3-Clause
248373
249016
  */
248374
249017
 
248375
- var SourceMapGenerator = __webpack_require__(1880)/* .SourceMapGenerator */ .h;
248376
- var util = __webpack_require__(5454);
249018
+ var SourceMapGenerator = __webpack_require__(34433)/* .SourceMapGenerator */ .h;
249019
+ var util = __webpack_require__(32728);
248377
249020
 
248378
249021
  // Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
248379
249022
  // operating systems these days (capturing the result).
@@ -248782,7 +249425,7 @@ __webpack_unused_export__ = SourceNode;
248782
249425
 
248783
249426
  /***/ }),
248784
249427
 
248785
- /***/ 5454:
249428
+ /***/ 32728:
248786
249429
  /***/ ((__unused_webpack_module, exports) => {
248787
249430
 
248788
249431
  /* -*- Mode: js; js-indent-level: 2; -*- */
@@ -249277,7 +249920,7 @@ exports.computeSourceURL = computeSourceURL;
249277
249920
 
249278
249921
  /***/ }),
249279
249922
 
249280
- /***/ 39745:
249923
+ /***/ 49125:
249281
249924
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
249282
249925
 
249283
249926
  /*
@@ -249285,650 +249928,9 @@ exports.computeSourceURL = computeSourceURL;
249285
249928
  * Licensed under the New BSD license. See LICENSE.txt or:
249286
249929
  * http://opensource.org/licenses/BSD-3-Clause
249287
249930
  */
249288
- /* unused reexport */ __webpack_require__(1880)/* .SourceMapGenerator */ .h;
249289
- exports.SourceMapConsumer = __webpack_require__(66913).SourceMapConsumer;
249290
- /* unused reexport */ __webpack_require__(95121);
249291
-
249292
-
249293
- /***/ }),
249294
-
249295
- /***/ 20406:
249296
- /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
249297
-
249298
- __webpack_require__(76252).install();
249299
-
249300
-
249301
- /***/ }),
249302
-
249303
- /***/ 76252:
249304
- /***/ ((module, exports, __webpack_require__) => {
249305
-
249306
- /* module decorator */ module = __webpack_require__.nmd(module);
249307
- var SourceMapConsumer = __webpack_require__(39745).SourceMapConsumer;
249308
- var path = __webpack_require__(71017);
249309
-
249310
- var fs;
249311
- try {
249312
- fs = __webpack_require__(57147);
249313
- if (!fs.existsSync || !fs.readFileSync) {
249314
- // fs doesn't have all methods we need
249315
- fs = null;
249316
- }
249317
- } catch (err) {
249318
- /* nop */
249319
- }
249320
-
249321
- var bufferFrom = __webpack_require__(55420);
249322
-
249323
- /**
249324
- * Requires a module which is protected against bundler minification.
249325
- *
249326
- * @param {NodeModule} mod
249327
- * @param {string} request
249328
- */
249329
- function dynamicRequire(mod, request) {
249330
- return mod.require(request);
249331
- }
249332
-
249333
- // Only install once if called multiple times
249334
- var errorFormatterInstalled = false;
249335
- var uncaughtShimInstalled = false;
249336
-
249337
- // If true, the caches are reset before a stack trace formatting operation
249338
- var emptyCacheBetweenOperations = false;
249339
-
249340
- // Supports {browser, node, auto}
249341
- var environment = "auto";
249342
-
249343
- // Maps a file path to a string containing the file contents
249344
- var fileContentsCache = {};
249345
-
249346
- // Maps a file path to a source map for that file
249347
- var sourceMapCache = {};
249348
-
249349
- // Regex for detecting source maps
249350
- var reSourceMap = /^data:application\/json[^,]+base64,/;
249351
-
249352
- // Priority list of retrieve handlers
249353
- var retrieveFileHandlers = [];
249354
- var retrieveMapHandlers = [];
249355
-
249356
- function isInBrowser() {
249357
- if (environment === "browser")
249358
- return true;
249359
- if (environment === "node")
249360
- return false;
249361
- return ((typeof window !== 'undefined') && (typeof XMLHttpRequest === 'function') && !(window.require && window.module && window.process && window.process.type === "renderer"));
249362
- }
249363
-
249364
- function hasGlobalProcessEventEmitter() {
249365
- return ((typeof process === 'object') && (process !== null) && (typeof process.on === 'function'));
249366
- }
249367
-
249368
- function globalProcessVersion() {
249369
- if ((typeof process === 'object') && (process !== null)) {
249370
- return process.version;
249371
- } else {
249372
- return '';
249373
- }
249374
- }
249375
-
249376
- function globalProcessStderr() {
249377
- if ((typeof process === 'object') && (process !== null)) {
249378
- return process.stderr;
249379
- }
249380
- }
249381
-
249382
- function globalProcessExit(code) {
249383
- if ((typeof process === 'object') && (process !== null) && (typeof process.exit === 'function')) {
249384
- return process.exit(code);
249385
- }
249386
- }
249387
-
249388
- function handlerExec(list) {
249389
- return function(arg) {
249390
- for (var i = 0; i < list.length; i++) {
249391
- var ret = list[i](arg);
249392
- if (ret) {
249393
- return ret;
249394
- }
249395
- }
249396
- return null;
249397
- };
249398
- }
249399
-
249400
- var retrieveFile = handlerExec(retrieveFileHandlers);
249401
-
249402
- retrieveFileHandlers.push(function(path) {
249403
- // Trim the path to make sure there is no extra whitespace.
249404
- path = path.trim();
249405
- if (/^file:/.test(path)) {
249406
- // existsSync/readFileSync can't handle file protocol, but once stripped, it works
249407
- path = path.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
249408
- return drive ?
249409
- '' : // file:///C:/dir/file -> C:/dir/file
249410
- '/'; // file:///root-dir/file -> /root-dir/file
249411
- });
249412
- }
249413
- if (path in fileContentsCache) {
249414
- return fileContentsCache[path];
249415
- }
249416
-
249417
- var contents = '';
249418
- try {
249419
- if (!fs) {
249420
- // Use SJAX if we are in the browser
249421
- var xhr = new XMLHttpRequest();
249422
- xhr.open('GET', path, /** async */ false);
249423
- xhr.send(null);
249424
- if (xhr.readyState === 4 && xhr.status === 200) {
249425
- contents = xhr.responseText;
249426
- }
249427
- } else if (fs.existsSync(path)) {
249428
- // Otherwise, use the filesystem
249429
- contents = fs.readFileSync(path, 'utf8');
249430
- }
249431
- } catch (er) {
249432
- /* ignore any errors */
249433
- }
249434
-
249435
- return fileContentsCache[path] = contents;
249436
- });
249437
-
249438
- // Support URLs relative to a directory, but be careful about a protocol prefix
249439
- // in case we are in the browser (i.e. directories may start with "http://" or "file:///")
249440
- function supportRelativeURL(file, url) {
249441
- if (!file) return url;
249442
- var dir = path.dirname(file);
249443
- var match = /^\w+:\/\/[^\/]*/.exec(dir);
249444
- var protocol = match ? match[0] : '';
249445
- var startPath = dir.slice(protocol.length);
249446
- if (protocol && /^\/\w\:/.test(startPath)) {
249447
- // handle file:///C:/ paths
249448
- protocol += '/';
249449
- return protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, '/');
249450
- }
249451
- return protocol + path.resolve(dir.slice(protocol.length), url);
249452
- }
249453
-
249454
- function retrieveSourceMapURL(source) {
249455
- var fileData;
249456
-
249457
- if (isInBrowser()) {
249458
- try {
249459
- var xhr = new XMLHttpRequest();
249460
- xhr.open('GET', source, false);
249461
- xhr.send(null);
249462
- fileData = xhr.readyState === 4 ? xhr.responseText : null;
249463
-
249464
- // Support providing a sourceMappingURL via the SourceMap header
249465
- var sourceMapHeader = xhr.getResponseHeader("SourceMap") ||
249466
- xhr.getResponseHeader("X-SourceMap");
249467
- if (sourceMapHeader) {
249468
- return sourceMapHeader;
249469
- }
249470
- } catch (e) {
249471
- }
249472
- }
249473
-
249474
- // Get the URL of the source map
249475
- fileData = retrieveFile(source);
249476
- var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;
249477
- // Keep executing the search to find the *last* sourceMappingURL to avoid
249478
- // picking up sourceMappingURLs from comments, strings, etc.
249479
- var lastMatch, match;
249480
- while (match = re.exec(fileData)) lastMatch = match;
249481
- if (!lastMatch) return null;
249482
- return lastMatch[1];
249483
- };
249484
-
249485
- // Can be overridden by the retrieveSourceMap option to install. Takes a
249486
- // generated source filename; returns a {map, optional url} object, or null if
249487
- // there is no source map. The map field may be either a string or the parsed
249488
- // JSON object (ie, it must be a valid argument to the SourceMapConsumer
249489
- // constructor).
249490
- var retrieveSourceMap = handlerExec(retrieveMapHandlers);
249491
- retrieveMapHandlers.push(function(source) {
249492
- var sourceMappingURL = retrieveSourceMapURL(source);
249493
- if (!sourceMappingURL) return null;
249494
-
249495
- // Read the contents of the source map
249496
- var sourceMapData;
249497
- if (reSourceMap.test(sourceMappingURL)) {
249498
- // Support source map URL as a data url
249499
- var rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(',') + 1);
249500
- sourceMapData = bufferFrom(rawData, "base64").toString();
249501
- sourceMappingURL = source;
249502
- } else {
249503
- // Support source map URLs relative to the source URL
249504
- sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
249505
- sourceMapData = retrieveFile(sourceMappingURL);
249506
- }
249507
-
249508
- if (!sourceMapData) {
249509
- return null;
249510
- }
249511
-
249512
- return {
249513
- url: sourceMappingURL,
249514
- map: sourceMapData
249515
- };
249516
- });
249517
-
249518
- function mapSourcePosition(position) {
249519
- var sourceMap = sourceMapCache[position.source];
249520
- if (!sourceMap) {
249521
- // Call the (overrideable) retrieveSourceMap function to get the source map.
249522
- var urlAndMap = retrieveSourceMap(position.source);
249523
- if (urlAndMap) {
249524
- sourceMap = sourceMapCache[position.source] = {
249525
- url: urlAndMap.url,
249526
- map: new SourceMapConsumer(urlAndMap.map)
249527
- };
249528
-
249529
- // Load all sources stored inline with the source map into the file cache
249530
- // to pretend like they are already loaded. They may not exist on disk.
249531
- if (sourceMap.map.sourcesContent) {
249532
- sourceMap.map.sources.forEach(function(source, i) {
249533
- var contents = sourceMap.map.sourcesContent[i];
249534
- if (contents) {
249535
- var url = supportRelativeURL(sourceMap.url, source);
249536
- fileContentsCache[url] = contents;
249537
- }
249538
- });
249539
- }
249540
- } else {
249541
- sourceMap = sourceMapCache[position.source] = {
249542
- url: null,
249543
- map: null
249544
- };
249545
- }
249546
- }
249547
-
249548
- // Resolve the source URL relative to the URL of the source map
249549
- if (sourceMap && sourceMap.map && typeof sourceMap.map.originalPositionFor === 'function') {
249550
- var originalPosition = sourceMap.map.originalPositionFor(position);
249551
-
249552
- // Only return the original position if a matching line was found. If no
249553
- // matching line is found then we return position instead, which will cause
249554
- // the stack trace to print the path and line for the compiled file. It is
249555
- // better to give a precise location in the compiled file than a vague
249556
- // location in the original file.
249557
- if (originalPosition.source !== null) {
249558
- originalPosition.source = supportRelativeURL(
249559
- sourceMap.url, originalPosition.source);
249560
- return originalPosition;
249561
- }
249562
- }
249563
-
249564
- return position;
249565
- }
249566
-
249567
- // Parses code generated by FormatEvalOrigin(), a function inside V8:
249568
- // https://code.google.com/p/v8/source/browse/trunk/src/messages.js
249569
- function mapEvalOrigin(origin) {
249570
- // Most eval() calls are in this format
249571
- var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
249572
- if (match) {
249573
- var position = mapSourcePosition({
249574
- source: match[2],
249575
- line: +match[3],
249576
- column: match[4] - 1
249577
- });
249578
- return 'eval at ' + match[1] + ' (' + position.source + ':' +
249579
- position.line + ':' + (position.column + 1) + ')';
249580
- }
249581
-
249582
- // Parse nested eval() calls using recursion
249583
- match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
249584
- if (match) {
249585
- return 'eval at ' + match[1] + ' (' + mapEvalOrigin(match[2]) + ')';
249586
- }
249587
-
249588
- // Make sure we still return useful information if we didn't find anything
249589
- return origin;
249590
- }
249591
-
249592
- // This is copied almost verbatim from the V8 source code at
249593
- // https://code.google.com/p/v8/source/browse/trunk/src/messages.js. The
249594
- // implementation of wrapCallSite() used to just forward to the actual source
249595
- // code of CallSite.prototype.toString but unfortunately a new release of V8
249596
- // did something to the prototype chain and broke the shim. The only fix I
249597
- // could find was copy/paste.
249598
- function CallSiteToString() {
249599
- var fileName;
249600
- var fileLocation = "";
249601
- if (this.isNative()) {
249602
- fileLocation = "native";
249603
- } else {
249604
- fileName = this.getScriptNameOrSourceURL();
249605
- if (!fileName && this.isEval()) {
249606
- fileLocation = this.getEvalOrigin();
249607
- fileLocation += ", "; // Expecting source position to follow.
249608
- }
249609
-
249610
- if (fileName) {
249611
- fileLocation += fileName;
249612
- } else {
249613
- // Source code does not originate from a file and is not native, but we
249614
- // can still get the source position inside the source string, e.g. in
249615
- // an eval string.
249616
- fileLocation += "<anonymous>";
249617
- }
249618
- var lineNumber = this.getLineNumber();
249619
- if (lineNumber != null) {
249620
- fileLocation += ":" + lineNumber;
249621
- var columnNumber = this.getColumnNumber();
249622
- if (columnNumber) {
249623
- fileLocation += ":" + columnNumber;
249624
- }
249625
- }
249626
- }
249627
-
249628
- var line = "";
249629
- var functionName = this.getFunctionName();
249630
- var addSuffix = true;
249631
- var isConstructor = this.isConstructor();
249632
- var isMethodCall = !(this.isToplevel() || isConstructor);
249633
- if (isMethodCall) {
249634
- var typeName = this.getTypeName();
249635
- // Fixes shim to be backward compatable with Node v0 to v4
249636
- if (typeName === "[object Object]") {
249637
- typeName = "null";
249638
- }
249639
- var methodName = this.getMethodName();
249640
- if (functionName) {
249641
- if (typeName && functionName.indexOf(typeName) != 0) {
249642
- line += typeName + ".";
249643
- }
249644
- line += functionName;
249645
- if (methodName && functionName.indexOf("." + methodName) != functionName.length - methodName.length - 1) {
249646
- line += " [as " + methodName + "]";
249647
- }
249648
- } else {
249649
- line += typeName + "." + (methodName || "<anonymous>");
249650
- }
249651
- } else if (isConstructor) {
249652
- line += "new " + (functionName || "<anonymous>");
249653
- } else if (functionName) {
249654
- line += functionName;
249655
- } else {
249656
- line += fileLocation;
249657
- addSuffix = false;
249658
- }
249659
- if (addSuffix) {
249660
- line += " (" + fileLocation + ")";
249661
- }
249662
- return line;
249663
- }
249664
-
249665
- function cloneCallSite(frame) {
249666
- var object = {};
249667
- Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function(name) {
249668
- object[name] = /^(?:is|get)/.test(name) ? function() { return frame[name].call(frame); } : frame[name];
249669
- });
249670
- object.toString = CallSiteToString;
249671
- return object;
249672
- }
249673
-
249674
- function wrapCallSite(frame, state) {
249675
- // provides interface backward compatibility
249676
- if (state === undefined) {
249677
- state = { nextPosition: null, curPosition: null }
249678
- }
249679
- if(frame.isNative()) {
249680
- state.curPosition = null;
249681
- return frame;
249682
- }
249683
-
249684
- // Most call sites will return the source file from getFileName(), but code
249685
- // passed to eval() ending in "//# sourceURL=..." will return the source file
249686
- // from getScriptNameOrSourceURL() instead
249687
- var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
249688
- if (source) {
249689
- var line = frame.getLineNumber();
249690
- var column = frame.getColumnNumber() - 1;
249691
-
249692
- // Fix position in Node where some (internal) code is prepended.
249693
- // See https://github.com/evanw/node-source-map-support/issues/36
249694
- // Header removed in node at ^10.16 || >=11.11.0
249695
- // v11 is not an LTS candidate, we can just test the one version with it.
249696
- // Test node versions for: 10.16-19, 10.20+, 12-19, 20-99, 100+, or 11.11
249697
- 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)/;
249698
- var headerLength = noHeader.test(globalProcessVersion()) ? 0 : 62;
249699
- if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) {
249700
- column -= headerLength;
249701
- }
249702
-
249703
- var position = mapSourcePosition({
249704
- source: source,
249705
- line: line,
249706
- column: column
249707
- });
249708
- state.curPosition = position;
249709
- frame = cloneCallSite(frame);
249710
- var originalFunctionName = frame.getFunctionName;
249711
- frame.getFunctionName = function() {
249712
- if (state.nextPosition == null) {
249713
- return originalFunctionName();
249714
- }
249715
- return state.nextPosition.name || originalFunctionName();
249716
- };
249717
- frame.getFileName = function() { return position.source; };
249718
- frame.getLineNumber = function() { return position.line; };
249719
- frame.getColumnNumber = function() { return position.column + 1; };
249720
- frame.getScriptNameOrSourceURL = function() { return position.source; };
249721
- return frame;
249722
- }
249723
-
249724
- // Code called using eval() needs special handling
249725
- var origin = frame.isEval() && frame.getEvalOrigin();
249726
- if (origin) {
249727
- origin = mapEvalOrigin(origin);
249728
- frame = cloneCallSite(frame);
249729
- frame.getEvalOrigin = function() { return origin; };
249730
- return frame;
249731
- }
249732
-
249733
- // If we get here then we were unable to change the source position
249734
- return frame;
249735
- }
249736
-
249737
- // This function is part of the V8 stack trace API, for more info see:
249738
- // https://v8.dev/docs/stack-trace-api
249739
- function prepareStackTrace(error, stack) {
249740
- if (emptyCacheBetweenOperations) {
249741
- fileContentsCache = {};
249742
- sourceMapCache = {};
249743
- }
249744
-
249745
- var name = error.name || 'Error';
249746
- var message = error.message || '';
249747
- var errorString = name + ": " + message;
249748
-
249749
- var state = { nextPosition: null, curPosition: null };
249750
- var processedStack = [];
249751
- for (var i = stack.length - 1; i >= 0; i--) {
249752
- processedStack.push('\n at ' + wrapCallSite(stack[i], state));
249753
- state.nextPosition = state.curPosition;
249754
- }
249755
- state.curPosition = state.nextPosition = null;
249756
- return errorString + processedStack.reverse().join('');
249757
- }
249758
-
249759
- // Generate position and snippet of original source with pointer
249760
- function getErrorSource(error) {
249761
- var match = /\n at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
249762
- if (match) {
249763
- var source = match[1];
249764
- var line = +match[2];
249765
- var column = +match[3];
249766
-
249767
- // Support the inline sourceContents inside the source map
249768
- var contents = fileContentsCache[source];
249769
-
249770
- // Support files on disk
249771
- if (!contents && fs && fs.existsSync(source)) {
249772
- try {
249773
- contents = fs.readFileSync(source, 'utf8');
249774
- } catch (er) {
249775
- contents = '';
249776
- }
249777
- }
249778
-
249779
- // Format the line from the original source code like node does
249780
- if (contents) {
249781
- var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
249782
- if (code) {
249783
- return source + ':' + line + '\n' + code + '\n' +
249784
- new Array(column).join(' ') + '^';
249785
- }
249786
- }
249787
- }
249788
- return null;
249789
- }
249790
-
249791
- function printErrorAndExit (error) {
249792
- var source = getErrorSource(error);
249793
-
249794
- // Ensure error is printed synchronously and not truncated
249795
- var stderr = globalProcessStderr();
249796
- if (stderr && stderr._handle && stderr._handle.setBlocking) {
249797
- stderr._handle.setBlocking(true);
249798
- }
249799
-
249800
- if (source) {
249801
- console.error();
249802
- console.error(source);
249803
- }
249804
-
249805
- console.error(error.stack);
249806
- globalProcessExit(1);
249807
- }
249808
-
249809
- function shimEmitUncaughtException () {
249810
- var origEmit = process.emit;
249811
-
249812
- process.emit = function (type) {
249813
- if (type === 'uncaughtException') {
249814
- var hasStack = (arguments[1] && arguments[1].stack);
249815
- var hasListeners = (this.listeners(type).length > 0);
249816
-
249817
- if (hasStack && !hasListeners) {
249818
- return printErrorAndExit(arguments[1]);
249819
- }
249820
- }
249821
-
249822
- return origEmit.apply(this, arguments);
249823
- };
249824
- }
249825
-
249826
- var originalRetrieveFileHandlers = retrieveFileHandlers.slice(0);
249827
- var originalRetrieveMapHandlers = retrieveMapHandlers.slice(0);
249828
-
249829
- exports.wrapCallSite = wrapCallSite;
249830
- exports.getErrorSource = getErrorSource;
249831
- exports.mapSourcePosition = mapSourcePosition;
249832
- exports.retrieveSourceMap = retrieveSourceMap;
249833
-
249834
- exports.install = function(options) {
249835
- options = options || {};
249836
-
249837
- if (options.environment) {
249838
- environment = options.environment;
249839
- if (["node", "browser", "auto"].indexOf(environment) === -1) {
249840
- throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}")
249841
- }
249842
- }
249843
-
249844
- // Allow sources to be found by methods other than reading the files
249845
- // directly from disk.
249846
- if (options.retrieveFile) {
249847
- if (options.overrideRetrieveFile) {
249848
- retrieveFileHandlers.length = 0;
249849
- }
249850
-
249851
- retrieveFileHandlers.unshift(options.retrieveFile);
249852
- }
249853
-
249854
- // Allow source maps to be found by methods other than reading the files
249855
- // directly from disk.
249856
- if (options.retrieveSourceMap) {
249857
- if (options.overrideRetrieveSourceMap) {
249858
- retrieveMapHandlers.length = 0;
249859
- }
249860
-
249861
- retrieveMapHandlers.unshift(options.retrieveSourceMap);
249862
- }
249863
-
249864
- // Support runtime transpilers that include inline source maps
249865
- if (options.hookRequire && !isInBrowser()) {
249866
- // Use dynamicRequire to avoid including in browser bundles
249867
- var Module = dynamicRequire(module, 'module');
249868
- var $compile = Module.prototype._compile;
249869
-
249870
- if (!$compile.__sourceMapSupport) {
249871
- Module.prototype._compile = function(content, filename) {
249872
- fileContentsCache[filename] = content;
249873
- sourceMapCache[filename] = undefined;
249874
- return $compile.call(this, content, filename);
249875
- };
249876
-
249877
- Module.prototype._compile.__sourceMapSupport = true;
249878
- }
249879
- }
249880
-
249881
- // Configure options
249882
- if (!emptyCacheBetweenOperations) {
249883
- emptyCacheBetweenOperations = 'emptyCacheBetweenOperations' in options ?
249884
- options.emptyCacheBetweenOperations : false;
249885
- }
249886
-
249887
- // Install the error reformatter
249888
- if (!errorFormatterInstalled) {
249889
- errorFormatterInstalled = true;
249890
- Error.prepareStackTrace = prepareStackTrace;
249891
- }
249892
-
249893
- if (!uncaughtShimInstalled) {
249894
- var installHandler = 'handleUncaughtExceptions' in options ?
249895
- options.handleUncaughtExceptions : true;
249896
-
249897
- // Do not override 'uncaughtException' with our own handler in Node.js
249898
- // Worker threads. Workers pass the error to the main thread as an event,
249899
- // rather than printing something to stderr and exiting.
249900
- try {
249901
- // We need to use `dynamicRequire` because `require` on it's own will be optimized by WebPack/Browserify.
249902
- var worker_threads = dynamicRequire(module, 'worker_threads');
249903
- if (worker_threads.isMainThread === false) {
249904
- installHandler = false;
249905
- }
249906
- } catch(e) {}
249907
-
249908
- // Provide the option to not install the uncaught exception handler. This is
249909
- // to support other uncaught exception handlers (in test frameworks, for
249910
- // example). If this handler is not installed and there are no other uncaught
249911
- // exception handlers, uncaught exceptions will be caught by node's built-in
249912
- // exception handler and the process will still be terminated. However, the
249913
- // generated JavaScript code will be shown above the stack trace instead of
249914
- // the original source code.
249915
- if (installHandler && hasGlobalProcessEventEmitter()) {
249916
- uncaughtShimInstalled = true;
249917
- shimEmitUncaughtException();
249918
- }
249919
- }
249920
- };
249921
-
249922
- exports.resetRetrieveHandlers = function() {
249923
- retrieveFileHandlers.length = 0;
249924
- retrieveMapHandlers.length = 0;
249925
-
249926
- retrieveFileHandlers = originalRetrieveFileHandlers.slice(0);
249927
- retrieveMapHandlers = originalRetrieveMapHandlers.slice(0);
249928
-
249929
- retrieveSourceMap = handlerExec(retrieveMapHandlers);
249930
- retrieveFile = handlerExec(retrieveFileHandlers);
249931
- }
249931
+ /* unused reexport */ __webpack_require__(34433)/* .SourceMapGenerator */ .h;
249932
+ exports.SourceMapConsumer = __webpack_require__(76771).SourceMapConsumer;
249933
+ /* unused reexport */ __webpack_require__(17085);
249932
249934
 
249933
249935
 
249934
249936
  /***/ }),