const args = parseArgv(argv, entrypointArgs);

const state = {

shouldUseChildProcess: false,

isInChildProcess: false,

isCli: true,

tsNodeScript: __filename,

parseArgvResult: args,

};

return bootstrap(state);

if (!state.phase2Result) {

state.phase2Result = phase2(state);

if (state.shouldUseChildProcess && !state.isInChildProcess) {

// Note: When transitioning into the child-process after `phase2`,

// the updated working directory needs to be preserved.

return (0, spawn_child_1.callInChild)(state);

}

}

if (!state.phase3Result) {

state.phase3Result = phase3(state);

if (state.shouldUseChildProcess && !state.isInChildProcess) {

// Note: When transitioning into the child-process after `phase2`,

// the updated working directory needs to be preserved.

return (0, spawn_child_1.callInChild)(state);

}

}

return phase4(state);

arg !== null && arg !== void 0 ? arg : (arg = require('arg'));

// HACK: technically, this function is not marked @internal so it's possible

// that libraries in the wild are doing `require('ts-node/dist/bin').main({'--transpile-only': true})`

// We can mark this function @internal in next major release.

// For now, rewrite args to avoid a breaking change.

entrypointArgs = { ...entrypointArgs };

for (const key of Object.keys(entrypointArgs)) {

entrypointArgs[key.replace(/([a-z])-([a-z])/g, (_$0, $1, $2) => `${$1}${$2.toUpperCase()}`)] = entrypointArgs[key];

}

const args = {

...entrypointArgs,

...arg({

// Node.js-like options.

'--eval': String,

'--interactive': Boolean,

'--print': Boolean,

'--require': [String],

// CLI options.

'--help': Boolean,

'--cwdMode': Boolean,

'--scriptMode': Boolean,

'--version': arg.COUNT,

'--showConfig': Boolean,

'--esm': Boolean,

// Project options.

'--cwd': String,

'--files': Boolean,

'--compiler': String,

'--compilerOptions': util_2.parse,

'--project': String,

'--ignoreDiagnostics': [String],

'--ignore': [String],

'--transpileOnly': Boolean,

'--transpiler': String,

'--swc': Boolean,

'--typeCheck': Boolean,

'--compilerHost': Boolean,

'--pretty': Boolean,

'--skipProject': Boolean,

'--skipIgnore': Boolean,

'--preferTsExts': Boolean,

'--logError': Boolean,

'--emit': Boolean,

'--scope': Boolean,

'--scopeDir': String,

'--noExperimentalReplAwait': Boolean,

'--experimentalSpecifierResolution': String,

// Aliases.

'-e': '--eval',

'-i': '--interactive',

'-p': '--print',

'-r': '--require',

'-h': '--help',

'-s': '--script-mode',

'-v': '--version',

'-T': '--transpileOnly',

'-H': '--compilerHost',

'-I': '--ignore',

'-P': '--project',

'-C': '--compiler',

'-D': '--ignoreDiagnostics',

'-O': '--compilerOptions',

'--dir': '--cwd',

// Support both tsc-style camelCase and node-style hypen-case for *all* flags

'--cwd-mode': '--cwdMode',

'--script-mode': '--scriptMode',

'--show-config': '--showConfig',

'--compiler-options': '--compilerOptions',

'--ignore-diagnostics': '--ignoreDiagnostics',

'--transpile-only': '--transpileOnly',

'--type-check': '--typeCheck',

'--compiler-host': '--compilerHost',

'--skip-project': '--skipProject',

'--skip-ignore': '--skipIgnore',

'--prefer-ts-exts': '--preferTsExts',

'--log-error': '--logError',

'--scope-dir': '--scopeDir',

'--no-experimental-repl-await': '--noExperimentalReplAwait',

'--experimental-specifier-resolution': '--experimentalSpecifierResolution',

}, {

argv,

stopAtPositional: true,

}),

};

// Only setting defaults for CLI-specific flags

// Anything passed to `register()` can be `undefined`; `create()` will apply

// defaults.

const { '--cwd': cwdArg, '--help': help = false, '--scriptMode': scriptMode, '--cwdMode': cwdMode, '--version': version = 0, '--showConfig': showConfig, '--require': argsRequire = [], '--eval': code = undefined, '--print': print = false, '--interactive': interactive = false, '--files': files, '--compiler': compiler, '--compilerOptions': compilerOptions, '--project': project, '--ignoreDiagnostics': ignoreDiagnostics, '--ignore': ignore, '--transpileOnly': transpileOnly, '--typeCheck': typeCheck, '--transpiler': transpiler, '--swc': swc, '--compilerHost': compilerHost, '--pretty': pretty, '--skipProject': skipProject, '--skipIgnore': skipIgnore, '--preferTsExts': preferTsExts, '--logError': logError, '--emit': emit, '--scope': scope = undefined, '--scopeDir': scopeDir = undefined, '--noExperimentalReplAwait': noExperimentalReplAwait, '--experimentalSpecifierResolution': experimentalSpecifierResolution, '--esm': esm, _: restArgs, } = args;

return {

// Note: argv and restArgs may be overwritten by child process

argv: process.argv,

restArgs,

cwdArg,

help,

scriptMode,

cwdMode,

version,

showConfig,

argsRequire,

code,

print,

interactive,

files,

compiler,

compilerOptions,

project,

ignoreDiagnostics,

ignore,

transpileOnly,

typeCheck,

transpiler,

swc,

compilerHost,

pretty,

skipProject,

skipIgnore,

preferTsExts,

logError,

emit,

scope,

scopeDir,

noExperimentalReplAwait,

experimentalSpecifierResolution,

esm,

};

const { help, version, cwdArg, esm } = payload.parseArgvResult;

if (help) {

console.log(`

process.exit(0);

}

// Output project information.

if (version === 1) {

console.log(`v${index_1.VERSION}`);

process.exit(0);

}

const cwd = cwdArg ? (0, path_1.resolve)(cwdArg) : process.cwd();

// If ESM is explicitly enabled through the flag, stage3 should be run in a child process

// with the ESM loaders configured.

if (esm)

payload.shouldUseChildProcess = true;

return {

cwd,

};

const { emit, files, pretty, transpileOnly, transpiler, noExperimentalReplAwait, typeCheck, swc, compilerHost, ignore, preferTsExts, logError, scriptMode, cwdMode, project, skipProject, skipIgnore, compiler, ignoreDiagnostics, compilerOptions, argsRequire, scope, scopeDir, esm, experimentalSpecifierResolution, } = payload.parseArgvResult;

const { cwd } = payload.phase2Result;

// NOTE: When we transition to a child process for ESM, the entry-point script determined

// here might not be the one used later in `phase4`. This can happen when we execute the

// original entry-point but then the process forks itself using e.g. `child_process.fork`.

// We will always use the original TS project in forked processes anyway, so it is

// expected and acceptable to retrieve the entry-point information here in `phase2`.

// See: https://github.com/TypeStrong/ts-node/issues/1812.

const { entryPointPath } = getEntryPointInfo(payload);

const preloadedConfig = (0, configuration_1.findAndReadConfig)({

cwd,

emit,

files,

pretty,

transpileOnly: (transpileOnly !== null && transpileOnly !== void 0 ? transpileOnly : transpiler != null) ? true : undefined,

experimentalReplAwait: noExperimentalReplAwait ? false : undefined,

typeCheck,

transpiler,

swc,

compilerHost,

ignore,

logError,

projectSearchDir: getProjectSearchDir(cwd, scriptMode, cwdMode, entryPointPath),

project,

skipProject,

skipIgnore,

compiler,

ignoreDiagnostics,

compilerOptions,

require: argsRequire,

scope,

scopeDir,

preferTsExts,

esm,

experimentalSpecifierResolution: experimentalSpecifierResolution,

});

// If ESM is enabled through the parsed tsconfig, stage4 should be run in a child

// process with the ESM loaders configured.

if (preloadedConfig.options.esm)

payload.shouldUseChildProcess = true;

return { preloadedConfig };

const { code, interactive, restArgs } = state.parseArgvResult;

const { cwd } = state.phase2Result;

const { isCli } = state;

// Figure out which we are executing: piped stdin, --eval, REPL, and/or entrypoint

// This is complicated because node's behavior is complicated

// `node -e code -i ./script.js` ignores -e

const executeEval = code != null && !(interactive && restArgs.length);

const executeEntrypoint = !executeEval && restArgs.length > 0;

const executeRepl = !executeEntrypoint &&

(interactive || (process.stdin.isTTY && !executeEval));

const executeStdin = !executeEval && !executeRepl && !executeEntrypoint;

/**

const entryPointPath = executeEntrypoint

? isCli

? (0, path_1.resolve)(cwd, restArgs[0])

: (0, path_1.resolve)(restArgs[0])

: undefined;

return {

executeEval,

executeEntrypoint,

executeRepl,

executeStdin,

entryPointPath,

};

var _a, _b, _c, _d, _e, _f, _g;

const { isInChildProcess, tsNodeScript } = payload;

const { version, showConfig, restArgs, code, print, argv } = payload.parseArgvResult;

const { cwd } = payload.phase2Result;

const { preloadedConfig } = payload.phase3Result;

const { entryPointPath, executeEntrypoint, executeEval, executeRepl, executeStdin, } = getEntryPointInfo(payload);

let evalStuff;

let replStuff;

let stdinStuff;

let evalAwarePartialHost = undefined;

if (executeEval) {

const state = new repl_1.EvalState((0, path_1.join)(cwd, repl_1.EVAL_FILENAME));

evalStuff = {

state,

repl: (0, repl_1.createRepl)({

state,

composeWithEvalAwarePartialHost: evalAwarePartialHost,

ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl: false,

}),

};

({ evalAwarePartialHost } = evalStuff.repl);

// Create a local module instance based on `cwd`.

const module = (evalStuff.module = new Module(repl_1.EVAL_NAME));

module.filename = evalStuff.state.path;

module.paths = Module._nodeModulePaths(cwd);

}

if (executeStdin) {

const state = new repl_1.EvalState((0, path_1.join)(cwd, repl_1.STDIN_FILENAME));

stdinStuff = {

state,

repl: (0, repl_1.createRepl)({

state,

composeWithEvalAwarePartialHost: evalAwarePartialHost,

ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl: false,

}),

};

({ evalAwarePartialHost } = stdinStuff.repl);

// Create a local module instance based on `cwd`.

const module = (stdinStuff.module = new Module(repl_1.STDIN_NAME));

module.filename = stdinStuff.state.path;

module.paths = Module._nodeModulePaths(cwd);

}

if (executeRepl) {

const state = new repl_1.EvalState((0, path_1.join)(cwd, repl_1.REPL_FILENAME));

replStuff = {

state,

repl: (0, repl_1.createRepl)({

state,

composeWithEvalAwarePartialHost: evalAwarePartialHost,

}),

};

({ evalAwarePartialHost } = replStuff.repl);

}

// Register the TypeScript compiler instance.

const service = (0, index_1.createFromPreloadedConfig)({

// Since this struct may have been marshalled across thread or process boundaries, we must restore

// un-marshall-able values.

...preloadedConfig,

options: {

...preloadedConfig.options,

readFile: (_a = evalAwarePartialHost === null || evalAwarePartialHost === void 0 ? void 0 : evalAwarePartialHost.readFile) !== null && _a !== void 0 ? _a : undefined,

fileExists: (_b = evalAwarePartialHost === null || evalAwarePartialHost === void 0 ? void 0 : evalAwarePartialHost.fileExists) !== null && _b !== void 0 ? _b : undefined,

tsTrace: index_1.DEFAULTS.tsTrace,

},

});

(0, index_1.register)(service);

if (isInChildProcess)

require('./child/child-loader').lateBindHooks((0, index_1.createEsmHooks)(service));

// Bind REPL service to ts-node compiler service (chicken-and-egg problem)

replStuff === null || replStuff === void 0 ? void 0 : replStuff.repl.setService(service);

evalStuff === null || evalStuff === void 0 ? void 0 : evalStuff.repl.setService(service);

stdinStuff === null || stdinStuff === void 0 ? void 0 : stdinStuff.repl.setService(service);

// Output project information.

if (version === 2) {

console.log(`ts-node v${index_1.VERSION}`);

console.log(`node ${process.version}`);

console.log(`compiler v${service.ts.version}`);

process.exit(0);

}

if (version >= 3) {

console.log(`ts-node v${index_1.VERSION} ${(0, path_1.dirname)(__dirname)}`);

console.log(`node ${process.version}`);

console.log(`compiler v${service.ts.version} ${(_c = service.compilerPath) !== null && _c !== void 0 ? _c : ''}`);

process.exit(0);

}

if (showConfig) {

const ts = service.ts;

if (typeof ts.convertToTSConfig !== 'function') {

console.error('Error: --showConfig requires a typescript versions >=3.2 that support --showConfig');

process.exit(1);

}

let moduleTypes = undefined;

if (service.options.moduleTypes) {

// Assumption: this codepath requires CLI invocation, so moduleTypes must have come from a tsconfig, not API.

const showRelativeTo = (0, path_1.dirname)(service.configFilePath);

moduleTypes = {};

for (const [key, value] of Object.entries(service.options.moduleTypes)) {

moduleTypes[(0, path_1.relative)(showRelativeTo, (0, path_1.resolve)((_d = service.options.optionBasePaths) === null || _d === void 0 ? void 0 : _d.moduleTypes, key))] = value;

}

}

const json = {

['ts-node']: {

...service.options,

require: ((_e = service.options.require) === null || _e === void 0 ? void 0 : _e.length)

? service.options.require

: undefined,

moduleTypes,

optionBasePaths: undefined,

compilerOptions: undefined,

project: (_f = service.configFilePath) !== null && _f !== void 0 ? _f : service.options.project,

},

...ts.convertToTSConfig(service.config, (_g = service.configFilePath) !== null && _g !== void 0 ? _g : (0, path_1.join)(cwd, 'ts-node-implicit-tsconfig.json'), service.ts.sys),

};

console.log(

// Assumes that all configuration options which can possibly be specified via the CLI are JSON-compatible.

// If, in the future, we must log functions, for example readFile and fileExists, then we can implement a JSON

// replacer function.

JSON.stringify(json, null, 2));

process.exit(0);

}

// Prepend `ts-node` arguments to CLI for child processes.

process.execArgv.push(tsNodeScript, ...argv.slice(2, argv.length - restArgs.length));

// TODO this comes from BootstrapState

process.argv = [process.argv[1]]

.concat(executeEntrypoint ? [entryPointPath] : [])

.concat(restArgs.slice(executeEntrypoint ? 1 : 0));

// Execute the main contents (either eval, script or piped).

if (executeEntrypoint) {

if (payload.isInChildProcess &&

(0, util_2.versionGteLt)(process.versions.node, '18.6.0')) {

// HACK workaround node regression

require('../dist-raw/runmain-hack.js').run(entryPointPath);

}

else {

Module.runMain();

}

}

else {

// Note: eval and repl may both run, but never with stdin.

// If stdin runs, eval and repl will not.

if (executeEval) {

(0, node_internal_modules_cjs_helpers_1.addBuiltinLibsToObject)(global);

evalAndExitOnTsError(evalStuff.repl, evalStuff.module, code, print, 'eval');

}

if (executeRepl) {

replStuff.repl.start();

}

if (executeStdin) {

let buffer = code || '';

process.stdin.on('data', (chunk) => (buffer += chunk));

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

evalAndExitOnTsError(stdinStuff.repl, stdinStuff.module, buffer,

// `echo 123 | node -p` still prints 123

print, 'stdin');

});

}

}

// Validate `--script-mode` / `--cwd-mode` / `--cwd` usage is correct.

if (scriptMode && cwdMode) {

throw new TypeError('--cwd-mode cannot be combined with --script-mode');

}

if (scriptMode && !scriptPath) {

throw new TypeError('--script-mode must be used with a script name, e.g. `ts-node --script-mode <script.ts>`');

}

const doScriptMode = scriptMode === true ? true : cwdMode === true ? false : !!scriptPath;

if (doScriptMode) {

// Use node's own resolution behavior to ensure we follow symlinks.

// scriptPath may omit file extension or point to a directory with or without package.json.

// This happens before we are registered, so we tell node's resolver to consider ts, tsx, and jsx files.

// In extremely rare cases, is is technically possible to resolve the wrong directory,

// because we do not yet know preferTsExts, jsx, nor allowJs.

// See also, justification why this will not happen in real-world situations:

// https://github.com/TypeStrong/ts-node/pull/1009#issuecomment-613017081

const exts = ['.js', '.jsx', '.ts', '.tsx'];

const extsTemporarilyInstalled = [];

for (const ext of exts) {

if (!(0, util_2.hasOwnProperty)(require.extensions, ext)) {

extsTemporarilyInstalled.push(ext);

require.extensions[ext] = function () { };

}

}

try {

return (0, path_1.dirname)(requireResolveNonCached(scriptPath));

}

finally {

for (const ext of extsTemporarilyInstalled) {

delete require.extensions[ext];

}

}

}

return cwd;

// node <= 12.1.x fallback: The trick below triggers a node bug on old versions.

// On these old versions, pollute the require cache instead. This is a deliberate

// ts-node limitation that will *rarely* manifest, and will not matter once node 12

// is end-of-life'd on 2022-04-30

const isSupportedNodeVersion = (0, util_2.versionGteLt)(process.versions.node, '12.2.0');

if (!isSupportedNodeVersion)

return require.resolve(absoluteModuleSpecifier);

const { dir, base } = (0, path_1.parse)(absoluteModuleSpecifier);

const relativeModuleSpecifier = `./${base}`;

const req = (0, util_2.createRequire)((0, path_1.join)(dir, 'imaginaryUncacheableRequireResolveScript'));

return req.resolve(relativeModuleSpecifier, {

paths: [

`${guaranteedNonexistentDirectoryPrefix}${guaranteedNonexistentDirectorySuffix++}`,

...(req.resolve.paths(relativeModuleSpecifier) || []),

],

});

let result;

(0, repl_1.setupContext)(global, module, filenameAndDirname);

try {

result = replService.evalCode(code);

}

catch (error) {

if (error instanceof index_1.TSError) {

console.error(error);

process.exit(1);

}

throw error;

}

if (isPrinted) {

console.log(typeof result === 'string'

? result

: (0, util_1.inspect)(result, { colors: process.stdout.isTTY }));

}