if (_processTopLevelAwait === undefined) {

({

processTopLevelAwait: _processTopLevelAwait,

} = require('../dist-raw/node-internal-repl-await'));

}

return _processTopLevelAwait;

if (diff === undefined) {

diff = require('diff');

}

return diff.diffLines;

var _a, _b, _c, _d, _e;

const { ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl = true } = options;

let service = options.service;

let nodeReplServer;

// If `useGlobal` is not true, then REPL creates a context when started.

// This stores a reference to it or to `global`, whichever is used, after REPL has started.

let context;

const state = (_a = options.state) !== null && _a !== void 0 ? _a : new EvalState((0, path_1.join)(process.cwd(), exports.REPL_FILENAME));

const evalAwarePartialHost = createEvalAwarePartialHost(state, options.composeWithEvalAwarePartialHost);

const stdin = (_b = options.stdin) !== null && _b !== void 0 ? _b : process.stdin;

const stdout = (_c = options.stdout) !== null && _c !== void 0 ? _c : process.stdout;

const stderr = (_d = options.stderr) !== null && _d !== void 0 ? _d : process.stderr;

const _console = stdout === process.stdout && stderr === process.stderr

? console

: new console_1.Console(stdout, stderr);

const replService = {

state: (_e = options.state) !== null && _e !== void 0 ? _e : new EvalState((0, path_1.join)(process.cwd(), exports.EVAL_FILENAME)),

setService,

evalCode,

evalCodeInternal,

nodeEval,

evalAwarePartialHost,

start,

startInternal,

stdin,

stdout,

stderr,

console: _console,

};

return replService;

function setService(_service) {

service = _service;

if (ignoreDiagnosticsThatAreAnnoyingInInteractiveRepl) {

service.addDiagnosticFilter({

appliesToAllFiles: false,

filenamesAbsolute: [state.path],

diagnosticsIgnored: [

2393,

6133,

7027,

...(service.shouldReplAwait ? topLevelAwaitDiagnosticCodes : []),

],

});

}

}

function evalCode(code) {

const result = appendCompileAndEvalInput({

service: service,

state,

input: code,

context,

overrideIsCompletion: false,

});

assert(result.containsTopLevelAwait === false);

return result.value;

}

function evalCodeInternal(options) {

const { code, enableTopLevelAwait, context } = options;

return appendCompileAndEvalInput({

service: service,

state,

input: code,

enableTopLevelAwait,

context,

});

}

function nodeEval(code, context, _filename, callback) {

// TODO: Figure out how to handle completion here.

if (code === '.scope') {

callback(null);

return;

}

try {

const evalResult = evalCodeInternal({

code,

enableTopLevelAwait: true,

context,

});

if (evalResult.containsTopLevelAwait) {

(async () => {

try {

callback(null, await evalResult.valuePromise);

}

catch (promiseError) {

handleError(promiseError);

}

})();

}

else {

callback(null, evalResult.value);

}

}

catch (error) {

handleError(error);

}

// Log TSErrors, check if they're recoverable, log helpful hints for certain

// well-known errors, and invoke `callback()`

// TODO should evalCode API get the same error-handling benefits?

function handleError(error) {

var _a, _b;

// Don't show TLA hint if the user explicitly disabled repl top level await

const canLogTopLevelAwaitHint = service.options.experimentalReplAwait !== false &&

!service.shouldReplAwait;

if (error instanceof index_1.TSError) {

// Support recoverable compilations using >= node 6.

if (repl_1.Recoverable && isRecoverable(error)) {

callback(new repl_1.Recoverable(error));

return;

}

else {

_console.error(error);

if (canLogTopLevelAwaitHint &&

error.diagnosticCodes.some((dC) => topLevelAwaitDiagnosticCodes.includes(dC))) {

_console.error(getTopLevelAwaitHint());

}

callback(null);

}

}

else {

let _error = error;

if (canLogTopLevelAwaitHint &&

_error instanceof SyntaxError &&

((_a = _error.message) === null || _a === void 0 ? void 0 : _a.includes('await is only valid'))) {

try {

// Only way I know to make our hint appear after the error

_error.message += `\n\n${getTopLevelAwaitHint()}`;

_error.stack = (_b = _error.stack) === null || _b === void 0 ? void 0 : _b.replace(/(SyntaxError:.*)/, (_, $1) => `${$1}\n\n${getTopLevelAwaitHint()}`);

}

catch { }

}

callback(_error);

}

}

function getTopLevelAwaitHint() {

return `Hint: REPL top-level await requires TypeScript version 3.8 or higher and target ES2018 or higher. You are using TypeScript ${service.ts.version} and target ${service.ts.ScriptTarget[service.config.options.target]}.`;

}

}

// Note: `code` argument is deprecated

function start(code) {

startInternal({ code });

}

// Note: `code` argument is deprecated

function startInternal(options) {

const { code, forceToBeModule = true, ...optionsOverride } = options !== null && options !== void 0 ? options : {};

// TODO assert that `service` is set; remove all `service!` non-null assertions

// Eval incoming code before the REPL starts.

// Note: deprecated

if (code) {

try {

evalCode(`${code}\n`);

}

catch (err) {

_console.error(err);

// Note: should not be killing the process here, but this codepath is deprecated anyway

process.exit(1);

}

}

// In case the typescript compiler hasn't compiled anything yet,

// make it run though compilation at least one time before

// the REPL starts for a snappier user experience on startup.

service === null || service === void 0 ? void 0 : service.compile('', state.path);

const repl = (0, repl_1.start)({

prompt: '> ',

input: replService.stdin,

output: replService.stdout,

// Mimicking node's REPL implementation: https://github.com/nodejs/node/blob/168b22ba073ee1cbf8d0bcb4ded7ff3099335d04/lib/internal/repl.js#L28-L30

terminal: stdout.isTTY &&

!parseInt(index_1.env.NODE_NO_READLINE, 10),

eval: nodeEval,

useGlobal: true,

...optionsOverride,

});

nodeReplServer = repl;

context = repl.context;

// Bookmark the point where we should reset the REPL state.

const resetEval = appendToEvalState(state, '');

function reset() {

resetEval();

// Hard fix for TypeScript forcing `Object.defineProperty(exports, ...)`.

runInContext('exports = module.exports', state.path, context);

if (forceToBeModule) {

state.input += 'export {};void 0;\n';

}

// Declare node builtins.

// Skip the same builtins as `addBuiltinLibsToObject`:

// those starting with _

// those containing /

// those that already exist as globals

// Intentionally suppress type errors in case @types/node does not declare any of them, and because

// `declare import` is technically invalid syntax.

// Avoid this when in transpileOnly, because third-party transpilers may not handle `declare import`.

if (!(service === null || service === void 0 ? void 0 : service.transpileOnly)) {

state.input += `// @ts-ignore\n${module_1.builtinModules

}

}

reset();

repl.on('reset', reset);

repl.defineCommand('type', {

help: 'Check the type of a TypeScript identifier',

action: function (identifier) {

if (!identifier) {

repl.displayPrompt();

return;

}

const undo = appendToEvalState(state, identifier);

const { name, comment } = service.getTypeInfo(state.input, state.path, state.input.length);

undo();

if (name)

repl.outputStream.write(`${name}\n`);

if (comment)

repl.outputStream.write(`${comment}\n`);

repl.displayPrompt();

},

});

// Set up REPL history when available natively via node.js >= 11.

if (repl.setupHistory) {

const historyPath = index_1.env.TS_NODE_HISTORY || (0, path_1.join)((0, os_1.homedir)(), '.ts_node_repl_history');

repl.setupHistory(historyPath, (err) => {

if (!err)

return;

_console.error(err);

process.exit(1);

});

}

return repl;

}

constructor(path) {

this.path = path;

/** @internal */

this.input = '';

/** @internal */

this.output = '';

/** @internal */

this.version = 0;

/** @internal */

this.lines = 0;

}

function readFile(path) {

if (path === state.path)

return state.input;

if (composeWith === null || composeWith === void 0 ? void 0 : composeWith.readFile)

return composeWith.readFile(path);

try {

return (0, fs_1.readFileSync)(path, 'utf8');

}

catch (err) {

/* Ignore. */

}

}

function fileExists(path) {

if (path === state.path)

return true;

if (composeWith === null || composeWith === void 0 ? void 0 : composeWith.fileExists)

return composeWith.fileExists(path);

try {

const stats = (0, fs_1.statSync)(path);

return stats.isFile() || stats.isFIFO();

}

catch (err) {

return false;

}

}

return { readFile, fileExists };

const { service, state, wrappedErr, enableTopLevelAwait = false, context, overrideIsCompletion, } = options;

let { input } = options;

// It's confusing for `{ a: 1 }` to be interpreted as a block statement

// rather than an object literal. So, we first try to wrap it in

// parentheses, so that it will be interpreted as an expression.

// Based on https://github.com/nodejs/node/blob/c2e6822153bad023ab7ebd30a6117dcc049e475c/lib/repl.js#L413-L422

let wrappedCmd = false;

if (!wrappedErr && /^\s*{/.test(input) && !/;\s*$/.test(input)) {

input = `(${input.trim()})\n`;

wrappedCmd = true;

}

const lines = state.lines;

const isCompletion = overrideIsCompletion !== null && overrideIsCompletion !== void 0 ? overrideIsCompletion : !/\n$/.test(input);

const undo = appendToEvalState(state, input);

let output;

// Based on https://github.com/nodejs/node/blob/92573721c7cff104ccb82b6ed3e8aa69c4b27510/lib/repl.js#L457-L461

function adjustUseStrict(code) {

// "void 0" keeps the repl from returning "use strict" as the result

// value for statements and declarations that don't return a value.

return code.replace(/^"use strict";/, '"use strict"; void 0;');

}

try {

output = service.compile(state.input, state.path, -lines);

}

catch (err) {

undo();

if (wrappedCmd) {

if (err instanceof index_1.TSError && err.diagnosticCodes[0] === 2339) {

// Ensure consistent and more sane behavior between { a: 1 }['b'] and ({ a: 1 }['b'])

throw err;

}

// Unwrap and try again

return appendCompileAndEvalInput({

...options,

wrappedErr: err,

});

}

if (wrappedErr)

throw wrappedErr;

throw err;

}

output = adjustUseStrict(output);

// Note: REPL does not respect sourcemaps!

// To properly do that, we'd need to prefix the code we eval -- which comes

// from `diffLines` -- with newlines so that it's at the proper line numbers.

// Then we'd need to ensure each bit of eval-ed code, if there are multiples,

// has the sourcemap appended to it.

// We might also need to integrate with our sourcemap hooks' cache; I'm not sure.

const outputWithoutSourcemapComment = output.replace(sourcemapCommentRe, '');

const oldOutputWithoutSourcemapComment = state.output.replace(sourcemapCommentRe, '');

// Use `diff` to check for new JavaScript to execute.

const changes = getDiffLines()(oldOutputWithoutSourcemapComment, outputWithoutSourcemapComment);

if (isCompletion) {

undo();

}

else {

state.output = output;

// Insert a semicolon to make sure that the code doesn't interact with the next line,

// for example to prevent `2\n+ 2` from producing 4.

// This is safe since the output will not change since we can only get here with successful inputs,

// and adding a semicolon to the end of a successful input won't ever change the output.

state.input = state.input.replace(/([^\n\s])([\n\s]*)$/, (all, lastChar, whitespace) => {

if (lastChar !== ';')

return `${lastChar};${whitespace}`;

return all;

});

}

let commands = [];

let containsTopLevelAwait = false;

// Build a list of "commands": bits of JS code in the diff that must be executed.

for (const change of changes) {

if (change.added) {

if (enableTopLevelAwait &&

service.shouldReplAwait &&

change.value.indexOf('await') > -1) {

const processTopLevelAwait = getProcessTopLevelAwait();

// Newline prevents comments to mess with wrapper

const wrappedResult = processTopLevelAwait(change.value + '\n');

if (wrappedResult !== null) {

containsTopLevelAwait = true;

commands.push({

mustAwait: true,

execCommand: () => runInContext(wrappedResult, state.path, context),

});

continue;

}

}

commands.push({

execCommand: () => runInContext(change.value, state.path, context),

});

}

}

// Execute all commands asynchronously if necessary, returning the result or a

// promise of the result.

if (containsTopLevelAwait) {

return {

containsTopLevelAwait,

valuePromise: (async () => {

let value;

for (const command of commands) {

const r = command.execCommand();

value = command.mustAwait ? await r : r;

}

return value;

})(),

};

}

else {

return {

containsTopLevelAwait: false,

value: commands.reduce((_, c) => c.execCommand(), undefined),

};

}

const script = new vm_1.Script(code, { filename });

if (context === undefined || context === global) {

return script.runInThisContext();

}

else {

return script.runInContext(context);

}

const undoInput = state.input;

const undoVersion = state.version;

const undoOutput = state.output;

const undoLines = state.lines;

state.input += input;

state.lines += lineCount(input);

state.version++;

return function () {

state.input = undoInput;

state.output = undoOutput;

state.version = undoVersion;

state.lines = undoLines;

};

let count = 0;

for (const char of value) {

if (char === '\n') {

count++;

}

}

return count;

return error.diagnosticCodes.every((code) => {

const deps = RECOVERY_CODES.get(code);

return (deps === null ||

(deps && error.diagnosticCodes.some((code) => deps.has(code))));

});

if (filenameAndDirname) {

context.__dirname = '.';

context.__filename = `[${filenameAndDirname}]`;

}

context.module = module;

context.exports = module.exports;

context.require = module.require.bind(module);