if (!(this instanceof Console)) {

return new Console(...arguments);

}

if (!options || typeof options.write === 'function') {

options = {

stdout: options,

stderr: arguments[1],

ignoreErrors: arguments[2]

};

}

const {

stdout,

stderr = stdout,

ignoreErrors = true,

colorMode = 'auto'

} = options;

if (!stdout || typeof stdout.write !== 'function') {

throw new ERR_CONSOLE_WRITABLE_STREAM('stdout');

}

if (!stderr || typeof stderr.write !== 'function') {

throw new ERR_CONSOLE_WRITABLE_STREAM('stderr');

}

const prop = {

writable: true,

enumerable: false,

configurable: true

};

Object.defineProperty(this, '_stdout', { ...prop, value: stdout });

Object.defineProperty(this, '_stderr', { ...prop, value: stderr });

Object.defineProperty(this, '_ignoreErrors', {

...prop,

value: Boolean(ignoreErrors),

});

Object.defineProperty(this, '_times', { ...prop, value: new Map() });

Object.defineProperty(this, '_stdoutErrorHandler', {

...prop,

value: createWriteErrorHandler(stdout),

});

Object.defineProperty(this, '_stderrErrorHandler', {

...prop,

value: createWriteErrorHandler(stderr),

});

if (typeof colorMode !== 'boolean' && colorMode !== 'auto')

throw new ERR_INVALID_ARG_VALUE('colorMode', colorMode);

this[kCounts] = new Map();

this[kColorMode] = colorMode;

Object.defineProperty(this, kGroupIndent, { writable: true });

this[kGroupIndent] = '';

// bind the prototype functions to this Console instance

var keys = Object.keys(Console.prototype);

for (var v = 0; v < keys.length; v++) {

var k = keys[v];

this[k] = this[k].bind(this);

}

return (err) => {

// This conditional evaluates to true if and only if there was an error

// that was not already emitted (which happens when the _write callback

// is invoked asynchronously).

if (err !== null && !stream._writableState.errorEmitted) {

// If there was an error, it will be emitted on `stream` as

// an `error` event. Adding a `once` listener will keep that error

// from becoming an uncaught exception, but since the handler is

// removed after the event, non-console.* writes won't be affected.

// we are only adding noop if there is no one else listening for 'error'

if (stream.listenerCount('error') === 0) {

stream.on('error', noop);

}

}

};

if (groupIndent.length !== 0) {

if (string.indexOf('\n') !== -1) {

string = string.replace(/\n/g, `\n${groupIndent}`);

}

string = groupIndent + string;

}

string += '\n';

if (ignoreErrors === false) return stream.write(string);

// There may be an error occurring synchronously (e.g. for files or TTYs

// on POSIX systems) or asynchronously (e.g. pipes on POSIX systems), so

// handle both situations.

try {

// Add and later remove a noop error handler to catch synchronous errors.

stream.once('error', noop);

stream.write(string, errorhandler);

} catch (e) {

// console is a debugging utility, so it swallowing errors is not desirable

// even in edge cases such as low stack space.

if (isStackOverflowError(e))

throw e;

// Sorry, there's no proper way to pass along the error here.

} finally {

stream.removeListener('error', noop);

}

write(this._ignoreErrors,

this._stdout,

this[kFormatForStdout](args),

this._stdoutErrorHandler,

this[kGroupIndent]);

write(this._ignoreErrors,

this._stderr,

this[kFormatForStderr](args),

this._stderrErrorHandler,

this[kGroupIndent]);

options = Object.assign({

customInspect: false

}, this[kGetInspectOptions](this._stdout), options);

write(this._ignoreErrors,

this._stdout,

util.inspect(object, options),

this._stdoutErrorHandler,

this[kGroupIndent]);

// Coerces everything other than Symbol to a string

label = `${label}`;

trace(kTraceBegin, kTraceConsoleCategory, `time::${label}`, 0);

this._times.set(label, process.hrtime());

// Coerces everything other than Symbol to a string

label = `${label}`;

const hasWarned = timeLogImpl(this, 'timeEnd', label);

trace(kTraceEnd, kTraceConsoleCategory, `time::${label}`, 0);

if (!hasWarned) {

this._times.delete(label);

}

// Coerces everything other than Symbol to a string

label = `${label}`;

timeLogImpl(this, 'timeLog', label, data);

trace(kTraceInstant, kTraceConsoleCategory, `time::${label}`, 0);

const time = self._times.get(label);

if (!time) {

process.emitWarning(`No such label '${label}' for console.${name}()`);

return true;

}

const duration = process.hrtime(time);

const ms = duration[0] * 1000 + duration[1] / 1e6;

if (data === undefined) {

self.log('%s: %sms', label, ms.toFixed(3));

} else {

self.log('%s: %sms', label, ms.toFixed(3), ...data);

}

return false;

const err = {

name: 'Trace',

message: this[kFormatForStderr](args)

};

Error.captureStackTrace(err, trace);

this.error(err.stack);

if (!expression) {

args[0] = `Assertion failed${args.length === 0 ? '' : `: ${args[0]}`}`;

this.warn(this[kFormatForStderr](args));

}

// It only makes sense to clear if _stdout is a TTY.

// Otherwise, do nothing.

if (this._stdout.isTTY) {

// The require is here intentionally to avoid readline being

// required too early when console is first loaded.

const { cursorTo, clearScreenDown } = require('readline');

cursorTo(this._stdout, 0, 0);

clearScreenDown(this._stdout);

}

// Ensures that label is a string, and only things that can be

// coerced to strings. e.g. Symbol is not allowed

label = `${label}`;

const counts = this[kCounts];

let count = counts.get(label);

if (count === undefined)

count = 1;

else

count++;

counts.set(label, count);

trace(kTraceCount, kTraceConsoleCategory, `count::${label}`, 0, count);

this.log(`${label}: ${count}`);

const counts = this[kCounts];

trace(kTraceCount, kTraceConsoleCategory, `count::${label}`, 0, 0);

counts.delete(`${label}`);

if (data.length > 0) {

this.log(...data);

}

this[kGroupIndent] += ' ';

if (properties !== undefined && !ArrayIsArray(properties))

throw new ERR_INVALID_ARG_TYPE('properties', 'Array', properties);

if (tabularData === null || typeof tabularData !== 'object')

return this.log(tabularData);

if (cliTable === undefined) cliTable = require('internal/cli_table');

const final = (k, v) => this.log(cliTable(k, v));

const inspect = (v) => {

const opt = { depth: 0, maxArrayLength: 3 };

if (v !== null && typeof v === 'object' &&

!isArray(v) && ObjectKeys(v).length > 2)

opt.depth = -1;

Object.assign(opt, this[kGetInspectOptions](this._stdout));

return util.inspect(v, opt);

};

const getIndexArray = (length) => ArrayFrom({ length }, (_, i) => inspect(i));

const mapIter = isMapIterator(tabularData);

let isKeyValue = false;

let i = 0;

if (mapIter) {

const res = previewEntries(tabularData, true);

tabularData = res[0];

isKeyValue = res[1];

}

if (isKeyValue || isMap(tabularData)) {

const keys = [];

const values = [];

let length = 0;

if (mapIter) {

for (; i < tabularData.length / 2; ++i) {

keys.push(inspect(tabularData[i * 2]));

values.push(inspect(tabularData[i * 2 + 1]));

length++;

}

} else {

for (const [k, v] of tabularData) {

keys.push(inspect(k));

values.push(inspect(v));

length++;

}

}

return final([

iterKey, keyKey, valuesKey

], [

getIndexArray(length),

keys,

values,

]);

}

const setIter = isSetIterator(tabularData);

if (setIter)

tabularData = previewEntries(tabularData);

const setlike = setIter || (mapIter && !isKeyValue) || isSet(tabularData);

if (setlike) {

const values = [];

let length = 0;

for (const v of tabularData) {

values.push(inspect(v));

length++;

}

return final([setlike ? iterKey : indexKey, valuesKey], [

getIndexArray(length),

values,

]);

}

const map = {};

let hasPrimitives = false;

const valuesKeyArray = [];

const indexKeyArray = ObjectKeys(tabularData);

for (; i < indexKeyArray.length; i++) {

const item = tabularData[indexKeyArray[i]];

const primitive = item === null ||

(typeof item !== 'function' && typeof item !== 'object');

if (properties === undefined && primitive) {

hasPrimitives = true;

valuesKeyArray[i] = inspect(item);

} else {

const keys = properties || ObjectKeys(item);

for (const key of keys) {

if (map[key] === undefined)

map[key] = [];

if ((primitive && properties) || !hasOwnProperty(item, key))

map[key][i] = '';

else

map[key][i] = item == null ? item : inspect(item[key]);

}

}

}

const keys = ObjectKeys(map);

const values = ObjectValues(map);

if (hasPrimitives) {

keys.push(valuesKey);

values.push(valuesKeyArray);

}

keys.unshift(indexKey);

values.unshift(indexKeyArray);

return final(keys, values);