// same length so that offsets are the same either way

return extension === 'mjs'

? 'export const test'

: 'exports.test ';

if(semver.gte(process.versions.node, '18.0.0')) {

return extension === 'mjs' ? 'Module\\.test' : '(?:Module\\.)?exports\\.test';

} else {

return extension === 'mjs' ? 'Module\\.test' : 'Module\\.exports\\.test';

}

if(extension === 'mjs') return 'file:/';

// Escape backslashes since we are returning regexp syntax

return path.parse(process.cwd()).root.replace(/\\/g, '\\\\');

// this re \((?:.*[/\\])?

return extension === 'mjs'

? `import {createRequire} from 'module';const require = createRequire(import.meta.url);`

: ` `;

assert(actual.length >= expected.length, 'got ' + actual.length + ' lines but expected at least ' + expected.length + ' lines\n' + util.inspect({actual, expected}));

for (var i = 0; i < expected.length; i++) {

// Some tests are regular expressions because the output format changed slightly between node v0.9.2 and v0.9.3

if (expected[i] instanceof RegExp) {

assert(expected[i].test(actual[i]), JSON.stringify(actual[i]) + ' does not match ' + expected[i] + '\n' + JSON.stringify({actual, expected: expected.map(v => typeof v === 'string' ? v : v.toString())}, null, 2));

} else {

assert.equal(actual[i], expected[i]);

}

}

return {

createEmptySourceMap,

createSourceMapWithGap,

createSingleLineSourceMap,

createSecondLineSourceMap,

createMultiLineSourceMap,

createMultiLineSourceMapWithSourcesContent

};

function createEmptySourceMap() {

return new SourceMapGenerator({

file: `.generated-${id}.${extension}`,

sourceRoot: '.'

});

}

function createSourceMapWithGap() {

var sourceMap = createEmptySourceMap();

sourceMap.addMapping({

generated: { line: 100, column: 0 },

original: { line: 100, column: 0 },

source: `.original-${id}.js`

});

return sourceMap;

}

function createSingleLineSourceMap() {

var sourceMap = createEmptySourceMap();

sourceMap.addMapping({

generated: { line: 1, column: 0 },

original: { line: 1, column: 0 },

source: `.original-${id}.js`

});

return sourceMap;

}

function createSecondLineSourceMap() {

var sourceMap = createEmptySourceMap();

sourceMap.addMapping({

generated: { line: 2, column: 0 },

original: { line: 1, column: 0 },

source: `.original-${id}.js`

});

return sourceMap;

}

function createMultiLineSourceMap() {

var sourceMap = createEmptySourceMap();

for (var i = 1; i <= 100; i++) {

sourceMap.addMapping({

generated: { line: i, column: 0 },

original: { line: 1000 + i, column: 99 + i },

source: 'line' + i + '.js'

});

}

return sourceMap;

}

function createMultiLineSourceMapWithSourcesContent() {

var sourceMap = createEmptySourceMap();

var original = new Array(1001).join('\n');

for (var i = 1; i <= 100; i++) {

sourceMap.addMapping({

generated: { line: i, column: 0 },

original: { line: 1000 + i, column: 4 },

source: `original-${id}.js`

});

original += ' line ' + i + '\n';

}

sourceMap.setSourceContent(`original-${id}.js`, original);

return sourceMap;

}

return expected.map(v => {

if(v instanceof RegExp) return new RegExp(v.source.replace(generatedFilenameIn, generatedFilenameOut));

return v.replace(generatedFilenameIn, generatedFilenameOut);

});

const header = srcPrefix();

// Check once with a separate source map

fs.writeFileSync(`.generated-${id}-separate.${extension}.map`, sourceMap.toString());

fs.writeFileSync(`.generated-${id}-separate.${extension}`, `${header}${namedExportDeclaration()} = function() {` +

source.join('\n') + `};//@ sourceMappingURL=.generated-${id}-separate.${extension}.map`);

let caught = false;

try {

await (await import(`./.generated-${id}-separate.${extension}`)).test();

} catch (e) {

caught = true;

compareLines(e.stack.split(/\r\n|\n/), rewriteExpectation(expected, `.generated-${id}`, `.generated-${id}-separate`));

}

if(!caught) throw new Error('expected to catch an error but none was thrown.');

// Check again with an inline source map (in a data URL)

fs.writeFileSync(`.generated-${id}-inline.${extension}`, `${header}${namedExportDeclaration()} = function() {` +

source.join('\n') + '};//@ sourceMappingURL=data:application/json;base64,' +

bufferFrom(sourceMap.toString()).toString('base64'));

caught = false;

try {

await (await import (`./.generated-${id}-inline.${extension}`)).test();

} catch (e) {

caught = true;

compareLines(e.stack.split(/\r\n|\n/), rewriteExpectation(expected, `.generated-${id}`, `.generated-${id}-inline`));

}

if(!caught) throw new Error('expected to catch an error but none was thrown.');

let header = srcPrefix();

fs.writeFileSync(`.original-${id}.js`, 'this is the original code');

fs.writeFileSync(`.generated-${id}.${extension}.map`, sourceMap.toString());

fs.writeFileSync(`.generated-${id}.${extension}`, header + source.join('\n') +

`//@ sourceMappingURL=.generated-${id}.${extension}.map`);

child_process.exec(`node ./.generated-${id}.${extension}`, function(error, stdout, stderr) {

try {

compareLines(

(stdout + stderr)

.trim()

.split(/\r\n|\n/)

// Empty lines are not relevant.

// Running in a debugger causes additional output.

.filter(function (line) { return line !== '' && line !== 'Debugger attached.' }),

expected

);

} catch (e) {

return done(e);

}

done();

});

underTest.install({

emptyCacheBetweenOperations: true // Needed to be able to test for failure

});

return {normalThrow, normalThrowWithoutSourceMapSupportInstalled};

async function normalThrow() {

await compareStackTrace(sourceMapConstructors.createMultiLineSourceMap(), [

'throw new Error("test");'

], [

'Error: test',

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?line1\.js:1001:101\)$`

]);

async function normalThrowWithoutSourceMapSupportInstalled() {

await compareStackTrace(sourceMapConstructors.createMultiLineSourceMap(), [

'throw new Error("test");'

], [

'Error: test',

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?\.generated-${id}\.${extension}:1:123\)$`

]);

for(const ext of ['cjs', 'mjs']) {

describe(`${ext} >`, () => {

beforeEach(function() {

extension = ext;

});

fn(...args);

});

}

function addPrefix(path) {return `${prefix}${path}`}

sourceMap.file = addPrefix(sourceMap.file);

if(sourceMap.sources) sourceMap.sources = sourceMap.sources.map(addPrefix);

return sourceMap;

// let createEmptySourceMap, createMultiLineSourceMap, createMultiLineSourceMapWithSourcesContent, createSecondLineSourceMap, createSingleLineSourceMap, createSourceMapWithGap})

const sourceMapConstructors = mapValues(sourceMapCreators(), v => flow(v, sourceMapPostprocessor));

const {createEmptySourceMap, createMultiLineSourceMap, createMultiLineSourceMapWithSourcesContent, createSecondLineSourceMap, createSingleLineSourceMap, createSourceMapWithGap} = sourceMapConstructors;

const {normalThrow} = getTestMacros(sourceMapConstructors);

// Run as a hook to ensure it runs even when we execute a subset of tests

before(installSmsOnce);

it('normal throw', async function() {

await normalThrow();

it('fs.readFileSync failure', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'var fs = require("fs");',

'var rfs = fs.readFileSync;',

'fs.readFileSync = function() {',

' throw new Error("no rfs for you");',

'};',

'try {',

' throw new Error("test");',

'} finally {',

' fs.readFileSync = rfs;',

'}'

], [

'Error: test',

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?line7\.js:1007:107\)$`

]);

it('throw inside function', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'function foo() {',

' throw new Error("test");',

'}',

'foo();'

], [

'Error: test',

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?line2\.js:1002:102\)$`,

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?line4\.js:1004:104\)$`

]);

it('throw inside function inside function', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'function foo() {',

' function bar() {',

' throw new Error("test");',

' }',

' bar();',

'}',

'foo();'

], [

'Error: test',

re`^ at bar \(${stackFramePathStartsWith()}(?:.*[/\\])?line3\.js:1003:103\)$`,

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?line5\.js:1005:105\)$`,

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?line7\.js:1007:107\)$`

]);

it('eval', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'eval("throw new Error(\'test\')");'

], [

'Error: test',

re`^ at eval \(eval at (<anonymous>|exports\.test|test) \(${stackFramePathStartsWith()}(?:.*[/\\])?line1\.js:1001:101\)`,

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?line1\.js:1001:101\)$`

]);

it('eval inside eval', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'eval("eval(\'throw new Error(\\"test\\")\')");'

], [

'Error: test',

re`^ at eval \(eval at (<anonymous>|exports\.test|test) \(eval at (<anonymous>|exports\.test|test) \(${stackFramePathStartsWith()}(?:.*[/\\])?line1\.js:1001:101\)`,

re`^ at eval \(eval at (<anonymous>|exports\.test|test) \(${stackFramePathStartsWith()}(?:.*[/\\])?line1\.js:1001:101\)`,

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?line1\.js:1001:101\)$`

]);

it('eval inside function', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'function foo() {',

' eval("throw new Error(\'test\')");',

'}',

'foo();'

], [

'Error: test',

re`^ at eval \(eval at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?line2\.js:1002:102\)`,

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?line2\.js:1002:102\)`,

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?line4\.js:1004:104\)$`

]);

it('eval with sourceURL', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'eval("throw new Error(\'test\')//@ sourceURL=sourceURL.js");'

], [

'Error: test',

/^ at eval \(sourceURL\.js:1:7\)$/,

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?line1\.js:1001:101\)$`

]);

it('eval with sourceURL inside eval', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'eval("eval(\'throw new Error(\\"test\\")//@ sourceURL=sourceURL.js\')");'

], [

'Error: test',

/^ at eval \(sourceURL\.js:1:7\)$/,

re`^ at eval \(eval at (<anonymous>|exports.test|test) \(${stackFramePathStartsWith()}(?:.*[/\\])?line1\.js:1001:101\)`,

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?line1\.js:1001:101\)$`

]);

it('native function', async function() {

await compareStackTrace(createSingleLineSourceMap(), [

'[1].map(function(x) { throw new Error(x); });'

], [

'Error: 1',

re`${stackFramePathStartsWith()}(?:.*[/\\])?.original-${id}.js`,

/at Array\.map \((native|<anonymous>)\)/

]);

it('function constructor', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'throw new Function(")");'

], [

/SyntaxError: Unexpected token '?\)'?/,

]);

if(semver.gte(process.version, '18.0.0')) {

it('async stack frames: async, Promise.allSettled', async function() {

await compareStackTrace(createMultiLineSourceMap(), [

'async function foo() { throw (await bar())[0].reason; }',

'async function bar() { return await Promise.allSettled([baz()]) }',

'async function baz() { await null; throw new Error("test"); }',

'return foo();'

], [

'Error: test',

re`^ at baz \(${stackFramePathStartsWith()}(?:.*[/\\])?line3.js:1003:103\)$`,

re`^ at async Promise\.allSettled \(index 0\)$`,

re`^ at async bar \(${stackFramePathStartsWith()}(?:.*[/\\])?line2.js:1002:102\)$`,

re`^ at async foo \(${stackFramePathStartsWith()}(?:.*[/\\])?line1.js:1001:101\)$`

]);

});

} else {

it('Verify node does not support Promise.allSettled stack frames. When this test starts breaking, we need to start testing for Promise.allSettled.', async () => {

// results1/driver1 is not strictly necessary to test allSettled; it is here to remind myself how to correctly get Promise.* methods to appear in a stack trace.

let result1;

await driver1().catch(e => result1 = e);

assert.match(result1.stack, /\bPromise\.all\b/);

// Copied from V8 tests: https://github.com/v8/v8/commit/89ed081c176e286f9d65f3821d43f568cd56a035#diff-1a0a032688d7546dcfe5730eaab2854fb1b8dab656d8bb940dffc71b7b975aae

async function fine() { }

async function thrower() {

await fine();

throw new Error();

}

async function driver1() {

return await Promise.all([fine(), fine(), thrower(), thrower()]);

}

async function driver2() {

return await Promise.allSettled([fine(), fine(), thrower(), thrower()]);

}

const results2 = await driver2();

assert.equal(results2[2].status, 'rejected');

assert.doesNotMatch(results2[2].reason.stack, /\bPromise\.allSettled\b/);

});

it('async stack frames: async, Promise.all'/*Promise.allSettled*/, async function() {

await compareStackTrace(createMultiLineSourceMap(), [

// Add once node upgrades to v8 10.2, where this was added: https://github.com/v8/v8/commit/89ed081c176e286f9d65f3821d43f568cd56a035

// 'async function foo() { return await bar(); }',

// 'async function bar() { return await Promise.allSettled([baz()]) }',

'async function foo() { return await bar(); }',

'async function bar() { await Promise.all([baz()]) }',

'async function baz() { await null; throw new Error("test"); }',

'return foo();'

], [

'Error: test',

re`^ at baz \(${stackFramePathStartsWith()}(?:.*[/\\])?line3.js:1003:103\)$`,

re`^ at async Promise\.all \(index 0\)$`,

re`^ at async bar \(${stackFramePathStartsWith()}(?:.*[/\\])?line2.js:1002:102\)$`,

re`^ at async foo \(${stackFramePathStartsWith()}(?:.*[/\\])?line1.js:1001:101\)$`

]);

it('async stack frames: Promise.any', async function() {

// node 14 and older does not have Promise.any

if(semver.lt(process.versions.node, '16.0.0')) return this.skip();

await compareStackTrace(createMultiLineSourceMap(), [

// Add once node upgrades to v8 10.2, where this was added: https://github.com/v8/v8/commit/89ed081c176e286f9d65f3821d43f568cd56a035

// 'async function foo() { return await bar(); }',

// 'async function bar() { return await Promise.allSettled([baz()]) }',

'async function foo() { return await bar(); }',

'async function bar() { await Promise.any([baz()]); }',

'async function baz() { await null; throw new Error("test"); }',

'return foo().catch(e => { throw e.errors[0] })'

], [

'Error: test',

re`^ at baz \(${stackFramePathStartsWith()}(?:.*[/\\])?line3.js:1003:103\)$`,

re`^ at async Promise\.any \(index 0\)$`,

re`^ at async bar \(${stackFramePathStartsWith()}(?:.*[/\\])?line2.js:1002:102\)$`,

re`^ at async foo \(${stackFramePathStartsWith()}(?:.*[/\\])?line1.js:1001:101\)$`

]);

it('wasm stack frames', async function() {

const wasmFrame = semver.gte(process.versions.node, '16.0.0')

? String.raw`wasm:\/\/wasm\/c2de0ab2:wasm-function\[1\]:0x3b`

: semver.gte(process.versions.node, '14.0.0')

? String.raw`call_js_function \(<anonymous>:wasm-function\[1\]:0x3b\)`

// Node 12

: String.raw`wasm-function\[1\]:0x3b`;

await compareStackTrace(createMultiLineSourceMap(), [

'return require("./test-fixtures/wasm/wasm.js").call_js_function(() => { throw new Error("test"); });'

], [

'Error: test',

re`^ at ${stackFramePathStartsWith()}(?:.*[/\\])?line1.js:1001:101$`,

re`^ at ${wasmFrame}$`,

re`^ at Object\.exports\.call_js_function \(.*[/\\]wasm\.js:13:24\)$`,

]);

it('throw with empty source map', async function() {

await compareStackTrace(createEmptySourceMap(), [

'throw new Error("test");'

], [

'Error: test',

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?\.generated-${id}.${extension}:1:123\)$`

]);

it('throw in Timeout with empty source map', function(done) {

compareStdout(done, createEmptySourceMap(), [

'require("./source-map-support").install();',

'setTimeout(function () {',

' throw new Error("this is the error")',

'})'

], [

re`${stackFramePathStartsWith()}(?:.*[/\\])?.generated-${id}.${extension}:3$`,

' throw new Error("this is the error")',

/^ \^$/,

'Error: this is the error',

re`^ at ((null)|(Timeout))\._onTimeout \(${stackFramePathStartsWith()}(?:.*[/\\])?.generated-${id}\.${extension}:3:11\)$`

]);

it('throw with source map with gap', async function() {

await compareStackTrace(createSourceMapWithGap(), [

'throw new Error("test");'

], [

'Error: test',

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?\.generated-${id}\.${extension}:1:123\)$`

]);

it('sourcesContent with data URL', async function() {

await compareStackTrace(createMultiLineSourceMapWithSourcesContent(), [

'throw new Error("test");'

], [

'Error: test',

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?original-${id}\.js:1001:5\)$`

]);

it('finds the last sourceMappingURL', async function() {

await compareStackTrace(createMultiLineSourceMapWithSourcesContent(), [

'//# sourceMappingURL=missing.map.js', // NB: compareStackTrace adds another source mapping.

'throw new Error("test");'

], [

'Error: test',

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?original-${id}\.js:1002:5\)$`

]);

it('maps original name from source', async function() {

var sourceMap = createEmptySourceMap();

sourceMap.addMapping({

generated: { line: 2, column: 8 },

original: { line: 1000, column: 10 },

source: `.original-${id}.js`,

});

sourceMap.addMapping({

generated: { line: 4, column: 0 },

original: { line: 1002, column: 1 },

source: `.original-${id}.js`,

name: "myOriginalName"

});

await compareStackTrace(sourceMap, [

'function foo() {',

' throw new Error("test");',

'}',

'foo();'

], [

'Error: test',

re`^ at myOriginalName \(${stackFramePathStartsWith()}(?:.*[/\\])?\.original-${id}.js:1000:11\)$`,

re`^ at ${stackFrameAtTest()} \(${stackFramePathStartsWith()}(?:.*[/\\])?\.original-${id}.js:1002:2\)$`

]);

it('default options', function(done) {

compareStdout(done, createSecondLineSourceMap(), [

'',

'function foo() { throw new Error("this is the error"); }',

'require("./source-map-support").install();',

'process.nextTick(foo);',

'process.nextTick(function() { process.exit(1); });'

], [

re`${stackFramePathStartsWith()}(?:.*[/\\])?.original-${id}\.js:1$`,

'this is the original code',

'^',

'Error: this is the error',

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?\.original-${id}\.js:1:1\)$`

]);

it('handleUncaughtExceptions is true', function(done) {

compareStdout(done, createSecondLineSourceMap(), [

'',

'function foo() { throw new Error("this is the error"); }',

'require("./source-map-support").install({ handleUncaughtExceptions: true });',

'process.nextTick(foo);'

], [

re`${stackFramePathStartsWith()}(?:.*[/\\])?.original-${id}\.js:1$`,

'this is the original code',

'^',

'Error: this is the error',

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?\.original-${id}\.js:1:1\)$`

]);

it('handleUncaughtExceptions is false', function(done) {

compareStdout(done, createSecondLineSourceMap(), [

'',

'function foo() { throw new Error("this is the error"); }',

'require("./source-map-support").install({ handleUncaughtExceptions: false });',

'process.nextTick(foo);'

], [

re`${stackFramePathStartsWith()}(?:.*[/\\])?.generated-${id}.${extension}:2$`,

'function foo() { throw new Error("this is the error"); }',

' ^',

'Error: this is the error',

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?.original-${id}\.js:1:1\)$`

]);

it('default options with empty source map', function(done) {

compareStdout(done, createEmptySourceMap(), [

'',

'function foo() { throw new Error("this is the error"); }',

'require("./source-map-support").install();',

'process.nextTick(foo);'

], [

re`${stackFramePathStartsWith()}(?:.*[/\\])?.generated-${id}.${extension}:2$`,

'function foo() { throw new Error("this is the error"); }',

' ^',

'Error: this is the error',

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?.generated-${id}.${extension}:2:24\)$`

]);

it('default options with source map with gap', function(done) {

compareStdout(done, createSourceMapWithGap(), [

'',

'function foo() { throw new Error("this is the error"); }',

'require("./source-map-support").install();',

'process.nextTick(foo);'

], [

re`${stackFramePathStartsWith()}(?:.*[/\\])?.generated-${id}.${extension}:2$`,

'function foo() { throw new Error("this is the error"); }',

' ^',

'Error: this is the error',

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?.generated-${id}.${extension}:2:24\)$`

]);

it('specifically requested error source', function(done) {

compareStdout(done, createSecondLineSourceMap(), [

'',

'function foo() { throw new Error("this is the error"); }',

'var sms = require("./source-map-support");',

'sms.install({ handleUncaughtExceptions: false });',

'process.on("uncaughtException", function (e) { console.log("SRC:" + sms.getErrorSource(e)); });',

'process.nextTick(foo);'

], [

re`^SRC:.*[/\\]\.original-${id}\.js:1$`,

'this is the original code',

'^'

]);

it('sourcesContent', function(done) {

compareStdout(done, createMultiLineSourceMapWithSourcesContent(), [

'',

'function foo() { throw new Error("this is the error"); }',

'require("./source-map-support").install();',

'process.nextTick(foo);',

'process.nextTick(function() { process.exit(1); });'

], [

re`${stackFramePathStartsWith()}(?:.*[/\\])?original-${id}\.js:1002$`,

' line 2',

' ^',

'Error: this is the error',

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?original-${id}\.js:1002:5\)$`

]);

it('missing source maps should also be cached', function(done) {

compareStdout(done, createSingleLineSourceMap(), [

'',

'var count = 0;',

'function foo() {',

' console.log(new Error("this is the error").stack.split("\\n").slice(0, 2).join("\\n"));',

'}',

'require("./source-map-support").install({',

' overrideRetrieveSourceMap: true,',

' retrieveSourceMap: function(name) {',

' if (/\\.generated-\\d+\\.(js|cjs|mjs)$/.test(name)) count++;',

' return null;',

' }',

'});',

'process.nextTick(foo);',

'process.nextTick(foo);',

'process.nextTick(function() { console.log(count); });',

], [

'Error: this is the error',

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?.generated-${id}.${extension}:4:15\)$`,

'Error: this is the error',

re`^ at foo \(${stackFramePathStartsWith()}(?:.*[/\\])?.generated-${id}.${extension}:4:15\)$`,

'1', // The retrieval should only be attempted once

]);

it('should consult all retrieve source map providers', function(done) {

// TODO are we supposed to be resolving this URL to absolute? Or should we test that non-absolute is supported?

// Test in vanilla source-map-support

let originalPath = path.resolve(`.original-${id}.js`);

if(extension === 'mjs') originalPath = pathToFileURL(originalPath).toString();

compareStdout(done, createSingleLineSourceMap(), [

'',

'var count = 0;',

'function foo() {',

' console.log(new Error("this is the error").stack.split("\\n").slice(0, 2).join("\\n"));',

'}',

'require("./source-map-support").install({',

' retrieveSourceMap: function(name) {',

` if (/\\.generated-${id}\\.${extension}$/.test(name)) count++;`,