try {

return process.cwd();

} catch {

// getcwd(3) can fail if the current working directory has been deleted.

// Fall back to the directory name of the (absolute) executable path.

// It's not really correct but what are the alternatives?

return path.dirname(process.execPath);

}

if (print) {

throw new ERR_EVAL_ESM_CANNOT_PRINT();

}

RegExpPrototypeExec(/^/, ''); // Necessary to reset RegExp statics before user code runs.

return require('internal/modules/run_main').runEntryPointWithESMLoader(

(loader) => loader.eval(source, getEvalModuleUrl(), true),

);

const origModule = globalThis.module; // Set e.g. when called from the REPL.

const module = createModule(name);

const baseUrl = pathToFileURL(module.filename).href;

if (shouldUseModuleEntryPoint(name, body)) {

return getOptionValue('--experimental-strip-types') ?

evalTypeScriptModuleEntryPoint(body, print) :

evalModuleEntryPoint(body, print);

}

const evalFunction = () => runScriptInContext(name,

body,

breakFirstLine,

print,

module,

baseUrl,

undefined,

origModule);

if (shouldLoadESM) {

return require('internal/modules/run_main').runEntryPointWithESMLoader(evalFunction);

}

evalFunction();

if (fn === null) {

exceptionHandlerState.captureFn = fn;

shouldAbortOnUncaughtToggle[0] = 1;

process.report.reportOnUncaughtException = exceptionHandlerState.reportFlag;

return;

}

if (typeof fn !== 'function') {

throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'null'], fn);

}

if (exceptionHandlerState.captureFn !== null) {

throw new ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET();

}

exceptionHandlerState.captureFn = fn;

shouldAbortOnUncaughtToggle[0] = 0;

exceptionHandlerState.reportFlag =

process.report.reportOnUncaughtException === true;

process.report.reportOnUncaughtException = false;

// The C++ land node::errors::TriggerUncaughtException() will

// exit the process if it returns false, and continue execution if it

// returns true (which indicates that the exception is handled by the user).

return (er, fromPromise) => {

// It's possible that defaultTriggerAsyncId was set for a constructor

// call that threw and was never cleared. So clear it now.

clearDefaultTriggerAsyncId();

const type = fromPromise ? 'unhandledRejection' : 'uncaughtException';

process.emit('uncaughtExceptionMonitor', er, type);

if (exceptionHandlerState.captureFn !== null) {

exceptionHandlerState.captureFn(er);

} else if (!process.emit('uncaughtException', er, type)) {

// If someone handled it, then great. Otherwise, die in C++ land

// since that means that we'll exit the process, emit the 'exit' event.

try {

if (!process._exiting) {

process._exiting = true;

process.exitCode = kGenericUserError;

process.emit('exit', kGenericUserError);

}

} catch {

// Nothing to be done about it at this point.

}

return false;

}

// If we handled an error, then make sure any ticks get processed

// by ensuring that the next Immediate cycle isn't empty.

require('timers').setImmediate(noop);

// Emit the after() hooks now that the exception has been handled.

if (afterHooksExist()) {

do {

const asyncId = executionAsyncId();

if (asyncId === 0)

popAsyncContext(0);

else

emitAfter(asyncId);

} while (hasAsyncIdStack());

}

// And completely empty the id stack, including anything that may be

// cached on the native side.

clearAsyncIdStack();

return true;

};

process.stdin.setEncoding('utf8');

let code = '';

process.stdin.on('data', (d) => {

code += d;

});

process.stdin.on('end', () => {

callback(code);

});

let index;

for (let i = 0; i < 3; i++) {

index = StringPrototypeIndexOf(originalStack, '\n', index + 1);

}

return StringPrototypeSlice(originalStack, 0, index) +

'\n' + newMessage +

StringPrototypeSlice(originalStack, index);

const origModule = globalThis.module; // Set e.g. when called from the REPL.

const module = createModule(name);

const baseUrl = pathToFileURL(module.filename).href;

if (shouldUseModuleEntryPoint(name, source)) {

return evalTypeScriptModuleEntryPoint(source, print);

}

let compiledScript;

// This variable can be modified if the source code is stripped.

let sourceToRun = source;

try {

compiledScript = compileScript(name, source, baseUrl);

} catch (originalError) {

try {

sourceToRun = stripTypeScriptModuleTypes(source, kEvalTag);

// Retry the CJS/ESM syntax detection after stripping the types.

if (shouldUseModuleEntryPoint(name, sourceToRun)) {

return evalTypeScriptModuleEntryPoint(source, print);

}

// If the ContextifiedScript was successfully created, execute it.

// outside the try-catch block to avoid catching runtime errors.

compiledScript = compileScript(name, sourceToRun, baseUrl);

} catch (tsError) {

// If it's invalid or unsupported TypeScript syntax, rethrow the original error

// with the TypeScript error message added to the stack.

if (tsError.code === 'ERR_INVALID_TYPESCRIPT_SYNTAX' || tsError.code === 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX') {

originalError.stack = decorateCJSErrorWithTSMessage(originalError.stack, tsError.message);

throw originalError;

}

throw tsError;

}

}

const evalFunction = () => runScriptInContext(name,

sourceToRun,

breakFirstLine,

print,

module,

baseUrl,

compiledScript,

origModule);

if (shouldLoadESM) {

return require('internal/modules/run_main').runEntryPointWithESMLoader(evalFunction);

}

evalFunction();

if (print) {

throw new ERR_EVAL_ESM_CANNOT_PRINT();

}

RegExpPrototypeExec(/^/, ''); // Necessary to reset RegExp statics before user code runs.

return require('internal/modules/run_main').runEntryPointWithESMLoader(

async (loader) => {

const url = getEvalModuleUrl();

let moduleWrap;

try {

// Compile the module to check for syntax errors.

moduleWrap = loader.createModuleWrap(source, url);

} catch (originalError) {

try {

const strippedSource = stripTypeScriptModuleTypes(source, kEvalTag);

// If the moduleWrap was successfully created, execute the module job.

// outside the try-catch block to avoid catching runtime errors.

moduleWrap = loader.createModuleWrap(strippedSource, url);

} catch (tsError) {

// If it's invalid or unsupported TypeScript syntax, rethrow the original error

// with the TypeScript error message added to the stack.

if (tsError.code === 'ERR_INVALID_TYPESCRIPT_SYNTAX' ||

tsError.code === 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX') {

originalError.stack = `${tsError.message}\n\n${originalError.stack}`;

throw originalError;

}

throw tsError;

}

}

// If the moduleWrap was successfully created either with by just compiling

// or after transpilation, execute the module job.

return loader.executeModuleJob(url, moduleWrap, true);

},

);

// We know its a TypeScript module, we can safely emit the experimental warning.

const strippedSource = stripTypeScriptModuleTypes(source, kEvalTag);

evalModuleEntryPoint(strippedSource, print);

// We know its a TypeScript module, we can safely emit the experimental warning.

const strippedSource = stripTypeScriptModuleTypes(source, kEvalTag);

evalScript(name, strippedSource, breakFirstLine, print, shouldLoadESM);

const hostDefinedOptionId = Symbol(name);

async function importModuleDynamically(specifier, _, importAttributes, phase) {

const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();

return cascadedLoader.import(specifier, baseUrl, importAttributes,

phase === 'source' ? kSourcePhase : kEvaluationPhase);

}

return makeContextifyScript(

body, // code

name, // filename,

0, // lineOffset

0, // columnOffset,

undefined, // cachedData

false, // produceCachedData

undefined, // parsingContext

hostDefinedOptionId, // hostDefinedOptionId

importModuleDynamically, // importModuleDynamically

);

return getOptionValue('--experimental-detect-module') &&

getOptionValue('--input-type') === '' &&

containsModuleSyntax(body, name, null, 'no CJS variables');

const CJSModule = require('internal/modules/cjs/loader').Module;

const cwd = tryGetCwd();

const module = new CJSModule(name);

module.filename = path.join(cwd, name);

module.paths = CJSModule._nodeModulePaths(cwd);

return module;

// Create wrapper for cache entry

const script = `

globalThis.__filename = name;

RegExpPrototypeExec(/^/, ''); // Necessary to reset RegExp statics before user code runs.

const result = module._compile(script, `${name}-wrapper`)(() => {

// If the script was already compiled, use it.

return runScriptInThisContext(

compiledScript ?? compileScript(name, body, baseUrl),

true, !!breakFirstLine);

});

if (print) {

const { log } = require('internal/console/global');

process.on('exit', () => {

log(result);

});

}

if (origModule !== undefined)

globalThis.module = origModule;