/* 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 internalUtil = require('internal/util');

const util = require('util');

const inherits = util.inherits;

const Stream = require('stream');

const vm = require('vm');

const path = require('path');

const fs = require('fs');

const rl = require('readline');

const Console = require('console').Console;

const Module = require('module');

const domain = require('domain');

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

const parentModule = module;

const replMap = new WeakMap();

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 = require('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.

exports.writer = util.inspect;

exports._builtinLibs = ['assert', 'buffer', 'child_process', 'cluster',

'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'http', 'https', 'net',

'os', 'path', 'punycode', 'querystring', 'readline', 'stream',

'string_decoder', 'tls', 'tty', 'url', 'util', 'v8', 'vm', 'zlib'];

const BLOCK_SCOPED_ERROR = 'Block-scoped declarations (let, ' +

'const, function, class) not yet supported outside strict mode';

class LineParser {

}

function REPLServer(prompt,

}

inherits(REPLServer, rl.Interface);

exports.REPLServer = REPLServer;

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

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

exports.REPL_MODE_MAGIC = Symbol('repl-magic');

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

};

REPLServer.prototype.createContext = function() {

};

REPLServer.prototype.resetContext = function() {

};

REPLServer.prototype.displayPrompt = function(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);

};

// A stream to push an array into a REPL

// used in REPLServer.complete

function ArrayStream() {

}

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

}

function filteredOwnPropertyNames(obj) {

if (!obj) return [];

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

}

// 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.pump'],

// 'util.' ]

//

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

// getter code.

REPLServer.prototype.complete = function(line, callback) {

};

/**

* Used to parse and execute the Node REPL commands.

*

* @param {keyword} keyword The command entered to check.

* @return {Boolean} If true it means don't continue parsing the command.

*/

REPLServer.prototype.parseREPLKeyword = function(keyword, rest) {

};

REPLServer.prototype.defineCommand = function(keyword, cmd) {

};

REPLServer.prototype.memory = function memory(cmd) {

};

function addStandardGlobals(completionGroups, filter) {