const {

ArrayPrototypeAt,

ArrayPrototypeFilter,

ArrayPrototypeFindLastIndex,

ArrayPrototypeForEach,

ArrayPrototypeIncludes,

ArrayPrototypeJoin,

ArrayPrototypeMap,

ArrayPrototypePop,

ArrayPrototypePush,

ArrayPrototypePushApply,

ArrayPrototypeShift,

ArrayPrototypeSlice,

ArrayPrototypeSome,

ArrayPrototypeSort,

ArrayPrototypeUnshift,

Boolean,

Error: MainContextError,

FunctionPrototypeBind,

JSONStringify,

MathMaxApply,

NumberIsNaN,

NumberParseFloat,

ObjectAssign,

ObjectDefineProperty,

ObjectGetOwnPropertyDescriptor,

ObjectGetOwnPropertyNames,

ObjectGetPrototypeOf,

ObjectKeys,

ObjectSetPrototypeOf,

Promise,

ReflectApply,

RegExp,

RegExpPrototypeExec,

SafePromiseRace,

SafeSet,

SafeWeakSet,

StringPrototypeCharAt,

StringPrototypeCodePointAt,

StringPrototypeEndsWith,

StringPrototypeIncludes,

StringPrototypeRepeat,

StringPrototypeSlice,

StringPrototypeSplit,

StringPrototypeStartsWith,

StringPrototypeToLocaleLowerCase,

StringPrototypeTrim,

StringPrototypeTrimStart,

Symbol,

SyntaxError,

SyntaxErrorPrototype,

globalThis,

} = primordials;

const {

isProxy,

} = require('internal/util/types');

const { BuiltinModule } = require('internal/bootstrap/realm');

const {

makeRequireFunction,

addBuiltinLibsToObject,

} = require('internal/modules/helpers');

const {

isIdentifierStart,

isIdentifierChar,

parse: acornParse,

} = require('internal/deps/acorn/acorn/dist/acorn');

const acornWalk = require('internal/deps/acorn/acorn-walk/dist/walk');

const {

decorateErrorStack,

isError,

deprecate,

deprecateInstantiation,

SideEffectFreeRegExpPrototypeSymbolReplace,

SideEffectFreeRegExpPrototypeSymbolSplit,

} = require('internal/util');

const { inspect } = require('internal/util/inspect');

const vm = require('vm');

const { runInThisContext, runInContext } = vm.Script.prototype;

const path = require('path');

const fs = require('fs');

const { Interface } = require('readline');

const {

commonPrefix,

} = require('internal/readline/utils');

const { Console } = require('console');

const { shouldColorize } = require('internal/util/colors');

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

let _builtinLibs = ArrayPrototypeFilter(

CJSModule.builtinModules,

(e) => e[0] !== '_' && !StringPrototypeStartsWith(e, 'node:'),

const nodeSchemeBuiltinLibs = ArrayPrototypeMap(

_builtinLibs, (lib) => `node:${lib}`);

BuiltinModule.getSchemeOnlyModuleNames(),

(lib) => ArrayPrototypePush(nodeSchemeBuiltinLibs, `node:${lib}`),

const domain = require('domain');

let debug = require('internal/util/debuglog').debuglog('repl', (fn) => {

debug = fn;

const {

ErrorPrepareStackTrace,

codes: {

ERR_CANNOT_WATCH_SIGINT,

ERR_INVALID_REPL_EVAL_CONFIG,

ERR_INVALID_REPL_INPUT,

ERR_MISSING_ARGS,

ERR_SCRIPT_EXECUTION_INTERRUPTED,

},

isErrorStackTraceLimitWritable,

overrideStackTrace,

} = require('internal/errors');

const { sendInspectorCommand } = require('internal/util/inspector');

const { getOptionValue } = require('internal/options');

const {

validateFunction,

validateObject,

} = require('internal/validators');

const experimentalREPLAwait = getOptionValue(

'--experimental-repl-await',

const pendingDeprecation = getOptionValue('--pending-deprecation');

const {

REPL_MODE_SLOPPY,

REPL_MODE_STRICT,

isRecoverableError,

kStandaloneREPL,

setupPreview,

setupReverseSearch,

isObjectLiteral,

} = require('internal/repl/utils');

const {

constants: {

ALL_PROPERTIES,

SKIP_SYMBOLS,

},

getOwnNonIndexProperties,

} = internalBinding('util');

const {

startSigintWatchdog,

stopSigintWatchdog,

} = internalBinding('contextify');

const {

extensionFormatMap,

} = require('internal/modules/esm/formats');

const {

makeContextifyScript,

} = require('internal/vm');

const {

kMultilinePrompt,

kAddNewLineOnTTY,

kLastCommandErrored,

} = require('internal/readline/interface');

let nextREPLResourceNumber = 1;

function getREPLResourceName() {

return `REPL${nextREPLResourceNumber++}`;

let processTopLevelAwait;

const globalBuiltins =

new SafeSet(vm.runInNewContext('Object.getOwnPropertyNames(globalThis)'));

const parentModule = module;

const domainSet = new SafeWeakSet();

const kBufferedCommandSymbol = Symbol('bufferedCommand');

const kContextId = Symbol('contextId');

const kLoadingSymbol = Symbol('loading');

let addedNewListener = false;

try {

// Hack for require.resolve("./relative") to work properly.

module.filename = path.resolve('repl');

} catch {

// path.resolve('repl') fails when 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?

const dirname = path.dirname(process.execPath);

module.filename = path.resolve(dirname, 'repl');

module.paths = CJSModule._nodeModulePaths(module.filename);

const writer = (obj) => inspect(obj, writer.options);

writer.options = { ...inspect.defaultOptions, showProxy: true };

const toDynamicImport = (codeLine) => {

function REPLServer(prompt,