// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

/* A repl library that you can include in your own code to get a runtime

* interface to your program.

*

* var repl = require("repl");

* // start repl on stdin

* repl.start("prompt> ");

*

* // listen for unix socket connections and start repl on them

* net.createServer(function(socket) {

* repl.start("node via Unix socket> ", socket);

* }).listen("/tmp/node-repl-sock");

*

* // listen for TCP socket connections and start repl on them

* net.createServer(function(socket) {

* repl.start("node via TCP socket> ", socket);

* }).listen(5001);

*

* // expose foo to repl context

* repl.start("node > ").context.foo = "stdin is fun";

*/

'use strict';

const internalModule = require('internal/module');

const { processTopLevelAwait } = require('internal/repl/await');

const internalUtil = require('internal/util');

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

const util = require('util');

const utilBinding = process.binding('util');

const { inherits } = util;

const Stream = require('stream');

const vm = require('vm');

const path = require('path');

const fs = require('fs');

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

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

const Module = require('module');

const domain = require('domain');

const debug = util.debuglog('repl');

const errors = require('internal/errors');

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

const parentModule = module;

const replMap = new WeakMap();

const GLOBAL_OBJECT_PROPERTIES = [

'NaN', 'Infinity', 'undefined', 'eval', 'parseInt', 'parseFloat', 'isNaN',

'isFinite', 'decodeURI', 'decodeURIComponent', 'encodeURI',

'encodeURIComponent', 'Object', 'Function', 'Array', 'String', 'Boolean',

'Number', 'Date', 'RegExp', 'Error', 'EvalError', 'RangeError',

'ReferenceError', 'SyntaxError', 'TypeError', 'URIError', 'Math', 'JSON'

];

const GLOBAL_OBJECT_PROPERTY_MAP = {};

for (var n = 0; n < GLOBAL_OBJECT_PROPERTIES.length; n++) {

GLOBAL_OBJECT_PROPERTY_MAP[GLOBAL_OBJECT_PROPERTIES[n]] =

GLOBAL_OBJECT_PROPERTIES[n];

}

const kBufferedCommandSymbol = Symbol('bufferedCommand');

const kContextId = Symbol('contextId');

try {

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

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

} catch (e) {

// 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');

}

// hack for repl require to work properly with node_modules folders

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

// If obj.hasOwnProperty has been overridden, then calling

// obj.hasOwnProperty(prop) will break.

// See: https://github.com/joyent/node/issues/1707

function hasOwnProperty(obj, prop) {

return Object.prototype.hasOwnProperty.call(obj, prop);

}

// Can overridden with custom print functions, such as `probe` or `eyes.js`.

// This is the default "writer" value if none is passed in the REPL options.

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

writer.options =

Object.assign({}, util.inspect.defaultOptions, { showProxy: true });

exports._builtinLibs = internalModule.builtinLibs;

function REPLServer(prompt,

stream,

eval_,

useGlobal,

ignoreUndefined,

replMode) {

if (!(this instanceof REPLServer)) {

return new REPLServer(prompt,

stream,

eval_,

useGlobal,

ignoreUndefined,

replMode);

}

var options, input, output, dom, breakEvalOnSigint;

if (prompt !== null && typeof prompt === 'object') {

// an options object was given

options = prompt;

stream = options.stream || options.socket;

input = options.input;

output = options.output;

eval_ = options.eval;

useGlobal = options.useGlobal;

ignoreUndefined = options.ignoreUndefined;

prompt = options.prompt;

dom = options.domain;

replMode = options.replMode;

breakEvalOnSigint = options.breakEvalOnSigint;

} else {

options = {};

}

if (breakEvalOnSigint && eval_) {

// Allowing this would not reflect user expectations.

// breakEvalOnSigint affects only the behavior of the default eval().

throw new errors.Error('ERR_INVALID_REPL_EVAL_CONFIG');

}

var self = this;

self._domain = dom || domain.create();

self.useGlobal = !!useGlobal;

self.ignoreUndefined = !!ignoreUndefined;

self.replMode = replMode || exports.REPL_MODE_SLOPPY;

self.underscoreAssigned = false;

self.last = undefined;

self.breakEvalOnSigint = !!breakEvalOnSigint;

self.editorMode = false;

// Context id for use with the inspector protocol.

self[kContextId] = undefined;

// just for backwards compat, see github.com/joyent/node/pull/7127

self.rli = this;

const savedRegExMatches = ['', '', '', '', '', '', '', '', '', ''];

const sep = '\u0000\u0000\u0000';

const regExMatcher = new RegExp(`^${sep}(.*)${sep}(.*)${sep}(.*)${sep}(.*)` +

`${sep}(.*)${sep}(.*)${sep}(.*)${sep}(.*)` +

`${sep}(.*)$`);

eval_ = eval_ || defaultEval;

// Pause taking in new input, and store the keys in a buffer.

const pausedBuffer = [];

let paused = false;

function pause() {

paused = true;

}

function unpause() {

if (!paused) return;

paused = false;

let entry;

while (entry = pausedBuffer.shift()) {

const [type, payload] = entry;

switch (type) {

case 'key': {

const [d, key] = payload;

self._ttyWrite(d, key);

break;

}

case 'close':

self.emit('exit');

break;

}

if (paused) {

break;

}

}

}

function defaultEval(code, context, file, cb) {

var err, result, script, wrappedErr;

var wrappedCmd = false;

var awaitPromise = false;

var input = code;

if (/^\s*\{/.test(code) && /\}\s*$/.test(code)) {

// 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.

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

wrappedCmd = true;

}

if (code.includes('await')) {

const potentialWrappedCode = processTopLevelAwait(code);

if (potentialWrappedCode !== null) {

code = potentialWrappedCode;

wrappedCmd = true;

awaitPromise = true;

}

}

// first, create the Script object to check the syntax

if (code === '\n')

return cb(null);

while (true) {

try {

if (!/^\s*$/.test(code) &&

self.replMode === exports.REPL_MODE_STRICT) {

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

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

code = `'use strict'; void 0;\n${code}`;

}

script = vm.createScript(code, {

filename: file,

displayErrors: true

});

} catch (e) {

debug('parse error %j', code, e);

if (wrappedCmd) {

// unwrap and try again

wrappedCmd = false;

awaitPromise = false;

code = input;

wrappedErr = e;

continue;

}

// preserve original error for wrapped command

const error = wrappedErr || e;

if (isRecoverableError(error, code))

err = new Recoverable(error);

else

err = error;

}

break;

}

// This will set the values from `savedRegExMatches` to corresponding

// predefined RegExp properties `RegExp.$1`, `RegExp.$2` ... `RegExp.$9`

regExMatcher.test(savedRegExMatches.join(sep));

let finished = false;

function finishExecution(err, result) {

if (finished) return;

finished = true;

// After executing the current expression, store the values of RegExp

// predefined properties back in `savedRegExMatches`

for (var idx = 1; idx < savedRegExMatches.length; idx += 1) {

savedRegExMatches[idx] = RegExp[`$${idx}`];

}

cb(err, result);

}

if (!err) {

// Unset raw mode during evaluation so that Ctrl+C raises a signal.

let previouslyInRawMode;

if (self.breakEvalOnSigint) {

// Start the SIGINT watchdog before entering raw mode so that a very

// quick Ctrl+C doesn't lead to aborting the process completely.

if (!utilBinding.startSigintWatchdog())

throw new errors.Error('ERR_CANNOT_WATCH_SIGINT');

previouslyInRawMode = self._setRawMode(false);

}

try {

try {

const scriptOptions = {

displayErrors: false,

breakOnSigint: self.breakEvalOnSigint

};

if (self.useGlobal) {

result = script.runInThisContext(scriptOptions);

} else {

result = script.runInContext(context, scriptOptions);

}

} finally {

if (self.breakEvalOnSigint) {

// Reset terminal mode to its previous value.

self._setRawMode(previouslyInRawMode);

// Returns true if there were pending SIGINTs *after* the script

// has terminated without being interrupted itself.

if (utilBinding.stopSigintWatchdog()) {

self.emit('SIGINT');

}

}

}

} catch (e) {

err = e;

if (err && err.code === 'ERR_SCRIPT_EXECUTION_INTERRUPTED') {

// The stack trace for this case is not very useful anyway.

Object.defineProperty(err, 'stack', { value: '' });

}

if (process.domain) {

debug('not recoverable, send to domain');

process.domain.emit('error', err);

process.domain.exit();

return;

}

}

if (awaitPromise && !err) {

let sigintListener;

pause();

let promise = result;

if (self.breakEvalOnSigint) {

const interrupt = new Promise((resolve, reject) => {

sigintListener = () => {

reject(new errors.Error('ERR_SCRIPT_EXECUTION_INTERRUPTED'));

};

prioritizedSigintQueue.add(sigintListener);

});

promise = Promise.race([promise, interrupt]);

}

promise.then((result) => {

// Remove prioritized SIGINT listener if it was not called.

// TODO(TimothyGu): Use Promise.prototype.finally when it becomes

// available.

prioritizedSigintQueue.delete(sigintListener);

finishExecution(undefined, result);

unpause();

}, (err) => {

// Remove prioritized SIGINT listener if it was not called.

prioritizedSigintQueue.delete(sigintListener);

if (err.code === 'ERR_SCRIPT_EXECUTION_INTERRUPTED') {

// The stack trace for this case is not very useful anyway.

Object.defineProperty(err, 'stack', { value: '' });

}

unpause();

if (err && process.domain) {

debug('not recoverable, send to domain');

process.domain.emit('error', err);

process.domain.exit();

return;

}

finishExecution(err);

});

}

}

if (!awaitPromise || err) {

finishExecution(err, result);

}

}

self.eval = self._domain.bind(eval_);

self._domain.on('error', function debugDomainError(e) {

debug('domain error');

const top = replMap.get(self);

const pstrace = Error.prepareStackTrace;

Error.prepareStackTrace = prepareStackTrace(pstrace);

if (typeof e === 'object')

internalUtil.decorateErrorStack(e);

Error.prepareStackTrace = pstrace;

const isError = internalUtil.isError(e);

if (e instanceof SyntaxError && e.stack) {

// remove repl:line-number and stack trace

e.stack = e.stack

.replace(/^repl:\d+\r?\n/, '')

.replace(/^\s+at\s.*\n?/gm, '');

} else if (isError && self.replMode === exports.REPL_MODE_STRICT) {

e.stack = e.stack.replace(/(\s+at\s+repl:)(\d+)/,

(_, pre, line) => pre + (line - 1));

}

if (isError && e.stack) {

top.outputStream.write(`${e.stack}\n`);

} else {

top.outputStream.write(`Thrown: ${String(e)}\n`);

}

top.clearBufferedCommand();

top.lines.level = [];

top.displayPrompt();

});

if (!input && !output) {

// legacy API, passing a 'stream'/'socket' option

if (!stream) {

// use stdin and stdout as the default streams if none were given

stream = process;

}

if (stream.stdin && stream.stdout) {

// We're given custom object with 2 streams, or the `process` object

input = stream.stdin;

output = stream.stdout;

} else {

// We're given a duplex readable/writable Stream, like a `net.Socket`

input = stream;

output = stream;

}

}

self.inputStream = input;

self.outputStream = output;

self.resetContext();

self.lines.level = [];

self.clearBufferedCommand();

Object.defineProperty(this, 'bufferedCommand', {

get: util.deprecate(() => self[kBufferedCommandSymbol],

'REPLServer.bufferedCommand is deprecated', 'DEP0074'),

set: util.deprecate((val) => self[kBufferedCommandSymbol] = val,

'REPLServer.bufferedCommand is deprecated', 'DEP0074'),

enumerable: true

});

// Figure out which "complete" function to use.

self.completer = (typeof options.completer === 'function') ?

options.completer : completer;

function completer(text, cb) {

complete.call(self, text, self.editorMode ?

self.completeOnEditorMode(cb) : cb);

}

Interface.call(this, {

input: self.inputStream,

output: self.outputStream,

completer: self.completer,

terminal: options.terminal,

historySize: options.historySize,

prompt

});

this.commands = Object.create(null);

defineDefaultCommands(this);

// figure out which "writer" function to use

self.writer = options.writer || exports.writer;

if (options.useColors === undefined) {

options.useColors = self.terminal;

}

self.useColors = !!options.useColors;

if (self.useColors && self.writer === writer) {

// Turn on ANSI coloring.

self.writer = (obj) => util.inspect(obj, self.writer.options);

self.writer.options = Object.assign({}, writer.options, { colors: true });

}

function filterInternalStackFrames(error, structuredStack) {

// search from the bottom of the call stack to

// find the first frame with a null function name

if (typeof structuredStack !== 'object')

return structuredStack;

const idx = structuredStack.reverse().findIndex(

(frame) => frame.getFunctionName() === null);

// if found, get rid of it and everything below it

structuredStack = structuredStack.splice(idx + 1);

return structuredStack;

}

function prepareStackTrace(fn) {

return (error, stackFrames) => {

const frames = filterInternalStackFrames(error, stackFrames);

if (fn) {

return fn(error, frames);

}

frames.push(error);

return frames.reverse().join('\n at ');

};

}

function _parseREPLKeyword(keyword, rest) {

var cmd = this.commands[keyword];

if (cmd) {

cmd.action.call(this, rest);

return true;

}

return false;

}

self.parseREPLKeyword = util.deprecate(

_parseREPLKeyword,

'REPLServer.parseREPLKeyword() is deprecated',

'DEP0075');

self.on('close', function emitExit() {

if (paused) {

pausedBuffer.push(['close']);

return;

}

self.emit('exit');

});

var sawSIGINT = false;

var sawCtrlD = false;

const prioritizedSigintQueue = new Set();

self.on('SIGINT', function onSigInt() {

if (prioritizedSigintQueue.size > 0) {

for (const task of prioritizedSigintQueue) {

task();

}

return;

}

var empty = self.line.length === 0;

self.clearLine();

_turnOffEditorMode(self);

const cmd = self[kBufferedCommandSymbol];

if (!(cmd && cmd.length > 0) && empty) {

if (sawSIGINT) {

self.close();

sawSIGINT = false;

return;

}

self.output.write('(To exit, press ^C again or type .exit)\n');

sawSIGINT = true;

} else {

sawSIGINT = false;

}

self.clearBufferedCommand();

self.lines.level = [];

self.displayPrompt();

});

self.on('line', function onLine(cmd) {

debug('line %j', cmd);

cmd = cmd || '';

sawSIGINT = false;

if (self.editorMode) {

self[kBufferedCommandSymbol] += cmd + '\n';

// code alignment

const matches = self._sawKeyPress ? cmd.match(/^\s+/) : null;

if (matches) {

const prefix = matches[0];

self.write(prefix);

self.line = prefix;

self.cursor = prefix.length;

}

_memory.call(self, cmd);

return;

}

// Check REPL keywords and empty lines against a trimmed line input.

const trimmedCmd = cmd.trim();

// Check to see if a REPL keyword was used. If it returns true,

// display next prompt and return.

if (trimmedCmd) {

if (trimmedCmd.charAt(0) === '.' && trimmedCmd.charAt(1) !== '.' &&

isNaN(parseFloat(trimmedCmd))) {

const matches = trimmedCmd.match(/^\.([^\s]+)\s*(.*)$/);

const keyword = matches && matches[1];

const rest = matches && matches[2];

if (_parseREPLKeyword.call(self, keyword, rest) === true) {

return;

}

if (!self[kBufferedCommandSymbol]) {

self.outputStream.write('Invalid REPL keyword\n');

finish(null);

return;

}

}

}

const evalCmd = self[kBufferedCommandSymbol] + cmd + '\n';

debug('eval %j', evalCmd);

self.eval(evalCmd, self.context, 'repl', finish);

function finish(e, ret) {

debug('finish', e, ret);

_memory.call(self, cmd);

if (e && !self[kBufferedCommandSymbol] && cmd.trim().startsWith('npm ')) {

self.outputStream.write('npm should be run outside of the ' +

'node repl, in your normal shell.\n' +

'(Press Control-D to exit.)\n');

self.clearBufferedCommand();

self.displayPrompt();

return;

}

// If error was SyntaxError and not JSON.parse error

if (e) {

if (e instanceof Recoverable && !sawCtrlD) {

// Start buffering data like that:

// {

// ... x: 1

// ... }

self[kBufferedCommandSymbol] += cmd + '\n';

self.displayPrompt();

return;

} else {

self._domain.emit('error', e.err || e);

}

}

// Clear buffer if no SyntaxErrors

self.clearBufferedCommand();

sawCtrlD = false;

// If we got any output - print it (if no error)

if (!e &&

// When an invalid REPL command is used, error message is printed

// immediately. We don't have to print anything else. So, only when

// the second argument to this function is there, print it.

arguments.length === 2 &&

(!self.ignoreUndefined || ret !== undefined)) {

if (!self.underscoreAssigned) {

self.last = ret;

}

self.outputStream.write(self.writer(ret) + '\n');

}

// Display prompt again

self.displayPrompt();

}

});

self.on('SIGCONT', function onSigCont() {

if (self.editorMode) {

self.outputStream.write(`${self._initialPrompt}.editor\n`);

self.outputStream.write(

'// Entering editor mode (^D to finish, ^C to cancel)\n');

self.outputStream.write(`${self[kBufferedCommandSymbol]}\n`);

self.prompt(true);

} else {

self.displayPrompt(true);

}

});

// Wrap readline tty to enable editor mode and pausing.

const ttyWrite = self._ttyWrite.bind(self);

self._ttyWrite = (d, key) => {

key = key || {};

if (paused && !(self.breakEvalOnSigint && key.ctrl && key.name === 'c')) {

pausedBuffer.push(['key', [d, key]]);

return;

}

if (!self.editorMode || !self.terminal) {

ttyWrite(d, key);

return;

}

// editor mode

if (key.ctrl && !key.shift) {

switch (key.name) {

case 'd': // End editor mode

_turnOffEditorMode(self);

sawCtrlD = true;

ttyWrite(d, { name: 'return' });

break;

case 'n': // Override next history item

case 'p': // Override previous history item

break;

default:

ttyWrite(d, key);

}

} else {

switch (key.name) {

case 'up': // Override previous history item

case 'down': // Override next history item

break;

case 'tab':

// prevent double tab behavior

self._previousKey = null;

ttyWrite(d, key);

break;

default:

ttyWrite(d, key);

}

}

};

self.displayPrompt();

}

inherits(REPLServer, Interface);

exports.REPLServer = REPLServer;

exports.REPL_MODE_SLOPPY = Symbol('repl-sloppy');

exports.REPL_MODE_STRICT = Symbol('repl-strict');

exports.REPL_MODE_MAGIC = exports.REPL_MODE_SLOPPY;

// prompt is a string to print on each line for the prompt,

// source is a stream to use for I/O, defaulting to stdin/stdout.

exports.start = function(prompt,

source,

eval_,

useGlobal,

ignoreUndefined,

replMode) {

var repl = new REPLServer(prompt,

source,

eval_,

useGlobal,

ignoreUndefined,

replMode);

if (!exports.repl) exports.repl = repl;

replMap.set(repl, repl);

return repl;

};

REPLServer.prototype.clearBufferedCommand = function clearBufferedCommand() {

this[kBufferedCommandSymbol] = '';

};

REPLServer.prototype.close = function close() {

if (this.terminal && this._flushing && !this._closingOnFlush) {

this._closingOnFlush = true;

this.once('flushHistory', () =>

Interface.prototype.close.call(this)

);

return;

}

process.nextTick(() =>

Interface.prototype.close.call(this)

);

};

REPLServer.prototype.createContext = function() {

var context;

if (this.useGlobal) {

context = global;

} else {

sendInspectorCommand((session) => {

session.post('Runtime.enable');

session.on('Runtime.executionContextCreated', ({ params }) => {

this[kContextId] = params.context.id;

});

context = vm.createContext();

session.post('Runtime.disable');

}, () => {

context = vm.createContext();

});

context.global = context;

const _console = new Console(this.outputStream);

Object.defineProperty(context, 'console', {

configurable: true,

enumerable: true,

get: () => _console

});

var names = Object.getOwnPropertyNames(global);

for (var n = 0; n < names.length; n++) {

var name = names[n];

if (name === 'console' || name === 'global')

continue;

if (GLOBAL_OBJECT_PROPERTY_MAP[name] === undefined) {

Object.defineProperty(context, name,

Object.getOwnPropertyDescriptor(global, name));

}

}

}

var module = new Module('<repl>');

module.paths = Module._resolveLookupPaths('<repl>', parentModule, true) || [];

var require = internalModule.makeRequireFunction(module);

context.module = module;

context.require = require;

internalModule.addBuiltinLibsToObject(context);

return context;

};

REPLServer.prototype.resetContext = function() {

this.context = this.createContext();

this.underscoreAssigned = false;

this.lines = [];

this.lines.level = [];

Object.defineProperty(this.context, '_', {

configurable: true,

get: () => this.last,

set: (value) => {

this.last = value;

if (!this.underscoreAssigned) {

this.underscoreAssigned = true;

this.outputStream.write('Expression assignment to _ now disabled.\n');

}

}

});

// Allow REPL extensions to extend the new context

this.emit('reset', this.context);

};

REPLServer.prototype.displayPrompt = function(preserveCursor) {

var prompt = this._initialPrompt;

if (this[kBufferedCommandSymbol].length) {

prompt = '...';

const len = this.lines.level.length ? this.lines.level.length - 1 : 0;

const levelInd = '..'.repeat(len);

prompt += levelInd + ' ';

}

// Do not overwrite `_initialPrompt` here

REPLServer.super_.prototype.setPrompt.call(this, prompt);

this.prompt(preserveCursor);

};

// When invoked as an API method, overwrite _initialPrompt

REPLServer.prototype.setPrompt = function setPrompt(prompt) {

this._initialPrompt = prompt;

REPLServer.super_.prototype.setPrompt.call(this, prompt);

};

REPLServer.prototype.turnOffEditorMode = util.deprecate(

function() { _turnOffEditorMode(this); },

'REPLServer.turnOffEditorMode() is deprecated',

'DEP0078');

// A stream to push an array into a REPL

// used in REPLServer.complete

function ArrayStream() {

Stream.call(this);

this.run = function(data) {

for (var n = 0; n < data.length; n++)

this.emit('data', `${data[n]}\n`);

};

}

util.inherits(ArrayStream, Stream);

ArrayStream.prototype.readable = true;

ArrayStream.prototype.writable = true;

ArrayStream.prototype.resume = function() {};

ArrayStream.prototype.write = function() {};

const requireRE = /\brequire\s*\(['"](([\w@./-]+\/)?(?:[\w@./-]*))/;

const simpleExpressionRE =

/(?:[a-zA-Z_$](?:\w|\$)*\.)*[a-zA-Z_$](?:\w|\$)*\.?$/;

function intFilter(item) {

// filters out anything not starting with A-Z, a-z, $ or _

return /^[A-Za-z_$]/.test(item);

}

const ARRAY_LENGTH_THRESHOLD = 1e6;

function mayBeLargeObject(obj) {

if (Array.isArray(obj)) {

return obj.length > ARRAY_LENGTH_THRESHOLD ? ['length'] : null;

} else if (isTypedArray(obj)) {

return obj.length > ARRAY_LENGTH_THRESHOLD ? [] : null;

}

return null;

}

function filteredOwnPropertyNames(obj) {

if (!obj) return [];

const fakeProperties = mayBeLargeObject(obj);

if (fakeProperties !== null) {

this.outputStream.write('\r\n');

process.emitWarning(

'The current array, Buffer or TypedArray has too many entries. ' +

'Certain properties may be missing from completion output.',

'REPLWarning',

undefined,

undefined,

true);

return fakeProperties;

}

return Object.getOwnPropertyNames(obj).filter(intFilter);

}

function getGlobalLexicalScopeNames(contextId) {

return sendInspectorCommand((session) => {

let names = [];

session.post('Runtime.globalLexicalScopeNames', {

executionContextId: contextId

}, (error, result) => {

if (!error) names = result.names;

});

return names;

}, () => []);

}

REPLServer.prototype.complete = function() {

this.completer.apply(this, arguments);

};

// Provide a list of completions for the given leading text. This is

// given to the readline interface for handling tab completion.

//

// Example:

// complete('var foo = util.')

// -> [['util.print', 'util.debug', 'util.log', 'util.inspect'],

// 'util.' ]

//

// Warning: This eval's code like "foo.bar.baz", so it will run property

// getter code.

function complete(line, callback) {

// There may be local variables to evaluate, try a nested REPL

if (this[kBufferedCommandSymbol] !== undefined &&

this[kBufferedCommandSymbol].length) {

// Get a new array of inputted lines

var tmp = this.lines.slice();

// Kill off all function declarations to push all local variables into

// global scope

for (var n = 0; n < this.lines.level.length; n++) {

var kill = this.lines.level[n];

if (kill.isFunction)

tmp[kill.line] = '';

}

var flat = new ArrayStream(); // make a new "input" stream

var magic = new REPLServer('', flat); // make a nested REPL

replMap.set(magic, replMap.get(this));

magic.resetContext();

flat.run(tmp); // eval the flattened code

// all this is only profitable if the nested REPL

// does not have a bufferedCommand

if (!magic[kBufferedCommandSymbol]) {

return magic.complete(line, callback);

}

}

var completions;

// list of completion lists, one for each inheritance "level"

var completionGroups = [];

var completeOn, i, group, c;

// REPL commands (e.g. ".break").

var filter;

var match = null;

match = line.match(/^\s*\.(\w*)$/);

if (match) {

completionGroups.push(Object.keys(this.commands));

completeOn = match[1];

if (match[1].length) {

filter = match[1];

}

completionGroupsLoaded();

} else if (match = line.match(requireRE)) {

// require('...<Tab>')

const exts = Object.keys(this.context.require.extensions);

var indexRe = new RegExp('^index(?:' + exts.map(regexpEscape).join('|') +

')$');

var versionedFileNamesRe = /-\d+\.\d+/;

completeOn = match[1];

var subdir = match[2] || '';

filter = match[1];

var dir, files, f, name, base, ext, abs, subfiles, s, isDirectory;

group = [];

let paths = [];

if (completeOn === '.') {

group = ['./', '../'];

} else if (completeOn === '..') {

group = ['../'];

} else if (/^\.\.?\//.test(completeOn)) {

paths = [process.cwd()];

} else {

paths = module.paths.concat(Module.globalPaths);

}

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