/* eslint node-core/documented-errors: "error" */

/* eslint node-core/alphabetize-errors: "error" */

/* eslint node-core/prefer-util-format-errors: "error" */

'use strict';

// The whole point behind this internal module is to allow Node.js to no

// longer be forced to treat every error message change as a semver-major

// change. The NodeError classes here all expose a `code` property whose

// value statically and permanently identifies the error. While the error

// message may change, the code should not.

const {

ArrayFrom,

ArrayIsArray,

ArrayPrototypeIncludes,

ArrayPrototypeIndexOf,

ArrayPrototypeJoin,

ArrayPrototypeMap,

ArrayPrototypePop,

ArrayPrototypePush,

ArrayPrototypeSlice,

ArrayPrototypeSplice,

ArrayPrototypeUnshift,

Error,

ErrorCaptureStackTrace,

ErrorPrototypeToString,

JSONStringify,

MathAbs,

MathMax,

Number,

NumberIsInteger,

ObjectDefineProperty,

ObjectKeys,

RangeError,

ReflectApply,

RegExpPrototypeTest,

SafeMap,

SafeWeakMap,

String,

StringPrototypeEndsWith,

StringPrototypeIncludes,

StringPrototypeSlice,

StringPrototypeSplit,

StringPrototypeStartsWith,

StringPrototypeToLowerCase,

Symbol,

SymbolFor,

SyntaxError,

TypeError,

URIError,

} = primordials;

const isWindows = process.platform === 'win32';

const messages = new SafeMap();

const codes = {};

const classRegExp = /^([A-Z][a-z0-9]*)+$/;

// Sorted by a rough estimate on most frequently used entries.

const kTypes = [

'string',

'function',

'number',

'object',

// Accept 'Function' and 'Object' as alternative to the lower cased version.

'Function',

'Object',

'boolean',

'bigint',

'symbol'

];

const MainContextError = Error;

const overrideStackTrace = new SafeWeakMap();

const kNoOverride = Symbol('kNoOverride');

const prepareStackTrace = (globalThis, error, trace) => {

// API for node internals to override error stack formatting

// without interfering with userland code.

if (overrideStackTrace.has(error)) {

const f = overrideStackTrace.get(error);

overrideStackTrace.delete(error);

return f(error, trace);

}

const globalOverride =

maybeOverridePrepareStackTrace(globalThis, error, trace);

if (globalOverride !== kNoOverride) return globalOverride;

// Normal error formatting:

//

// Error: Message

// at function (file)

// at file

const errorString = ErrorPrototypeToString(error);

if (trace.length === 0) {

return errorString;

}

return `${errorString}\n at ${trace.join('\n at ')}`;

};

const maybeOverridePrepareStackTrace = (globalThis, error, trace) => {

// Polyfill of V8's Error.prepareStackTrace API.

// https://crbug.com/v8/7848

// `globalThis` is the global that contains the constructor which

// created `error`.

if (typeof globalThis.Error?.prepareStackTrace === 'function') {

return globalThis.Error.prepareStackTrace(error, trace);

}

// We still have legacy usage that depends on the main context's `Error`

// being used, even when the error is from a different context.

// TODO(devsnek): evaluate if this can be eventually deprecated/removed.

if (typeof MainContextError.prepareStackTrace === 'function') {

return MainContextError.prepareStackTrace(error, trace);

}

return kNoOverride;

};

let excludedStackFn;

// Lazily loaded

let util;

let assert;

let internalUtil = null;

function lazyInternalUtil() {

if (!internalUtil) {

internalUtil = require('internal/util');

}

return internalUtil;

}

let internalUtilInspect = null;

function lazyInternalUtilInspect() {

if (!internalUtilInspect) {

internalUtilInspect = require('internal/util/inspect');

}

return internalUtilInspect;

}

let buffer;

function lazyBuffer() {

if (buffer === undefined)

buffer = require('buffer').Buffer;

return buffer;

}

// A specialized Error that includes an additional info property with

// additional information about the error condition.

// It has the properties present in a UVException but with a custom error

// message followed by the uv error code and uv error message.

// It also has its own error code with the original uv error context put into

// `err.info`.

// The context passed into this error must have .code, .syscall and .message,

// and may have .path and .dest.

class SystemError extends Error {

constructor(key, context) {

if (excludedStackFn === undefined) {

super();

} else {

const limit = Error.stackTraceLimit;

Error.stackTraceLimit = 0;

super();

// Reset the limit and setting the name property.

Error.stackTraceLimit = limit;

}

const prefix = getMessage(key, [], this);

let message = `${prefix}: ${context.syscall} returned ` +

`${context.code} (${context.message})`;

if (context.path !== undefined)

message += ` ${context.path}`;

if (context.dest !== undefined)

message += ` => ${context.dest}`;

ObjectDefineProperty(this, 'message', {

value: message,

enumerable: false,

writable: true,

configurable: true

});

addCodeToName(this, 'SystemError', key);

this.code = key;

ObjectDefineProperty(this, 'info', {

value: context,

enumerable: true,

configurable: true,

writable: false

});

ObjectDefineProperty(this, 'errno', {

get() {

return context.errno;

},

set: (value) => {

context.errno = value;

},

enumerable: true,

configurable: true

});

ObjectDefineProperty(this, 'syscall', {

get() {

return context.syscall;

},

set: (value) => {

context.syscall = value;

},

enumerable: true,

configurable: true

});

if (context.path !== undefined) {

// TODO(BridgeAR): Investigate why and when the `.toString()` was

// introduced. The `path` and `dest` properties in the context seem to

// always be of type string. We should probably just remove the

// `.toString()` and `Buffer.from()` operations and set the value on the

// context as the user did.

ObjectDefineProperty(this, 'path', {

get() {

return context.path != null ?

context.path.toString() : context.path;

},

set: (value) => {

context.path = value ?

lazyBuffer().from(value.toString()) : undefined;

},

enumerable: true,

configurable: true

});

}

if (context.dest !== undefined) {

ObjectDefineProperty(this, 'dest', {

get() {

return context.dest != null ?

context.dest.toString() : context.dest;

},

set: (value) => {

context.dest = value ?

lazyBuffer().from(value.toString()) : undefined;

},

enumerable: true,

configurable: true

});

}

}

toString() {

return `${this.name} [${this.code}]: ${this.message}`;

}

[SymbolFor('nodejs.util.inspect.custom')](recurseTimes, ctx) {

return lazyInternalUtilInspect().inspect(this, {

...ctx,

getters: true,

customInspect: false

});

}

}

function makeSystemErrorWithCode(key) {

return class NodeError extends SystemError {

constructor(ctx) {

super(key, ctx);

}

};

}

function makeNodeErrorWithCode(Base, key) {

return function NodeError(...args) {

let error;

if (excludedStackFn === undefined) {

error = new Base();

} else {

const limit = Error.stackTraceLimit;

Error.stackTraceLimit = 0;

error = new Base();

// Reset the limit and setting the name property.

Error.stackTraceLimit = limit;

}

const message = getMessage(key, args, error);

ObjectDefineProperty(error, 'message', {

value: message,

enumerable: false,

writable: true,

configurable: true,

});

ObjectDefineProperty(error, 'toString', {

value() {

return `${this.name} [${key}]: ${this.message}`;

},

enumerable: false,

writable: true,

configurable: true,

});

addCodeToName(error, Base.name, key);

error.code = key;

return error;

};

}

// This function removes unnecessary frames from Node.js core errors.

function hideStackFrames(fn) {

return function hidden(...args) {

// Make sure the most outer `hideStackFrames()` function is used.

let setStackFn = false;

if (excludedStackFn === undefined) {

excludedStackFn = hidden;

setStackFn = true;

}

try {

return fn(...args);

} finally {

if (setStackFn === true) {

excludedStackFn = undefined;

}

}

};

}

function addCodeToName(err, name, code) {

// Set the stack

if (excludedStackFn !== undefined) {

ErrorCaptureStackTrace(err, excludedStackFn);

}

// Add the error code to the name to include it in the stack trace.

err.name = `${name} [${code}]`;

// Access the stack to generate the error message including the error code

// from the name.

err.stack;

// Reset the name to the actual name.

if (name === 'SystemError') {

ObjectDefineProperty(err, 'name', {

value: name,

enumerable: false,

writable: true,

configurable: true

});

} else {

delete err.name;

}

}

// Utility function for registering the error codes. Only used here. Exported

// *only* to allow for testing.

function E(sym, val, def, ...otherClasses) {

// Special case for SystemError that formats the error message differently

// The SystemErrors only have SystemError as their base classes.

messages.set(sym, val);

if (def === SystemError) {

def = makeSystemErrorWithCode(sym);

} else {

def = makeNodeErrorWithCode(def, sym);

}

if (otherClasses.length !== 0) {

otherClasses.forEach((clazz) => {

def[clazz.name] = makeNodeErrorWithCode(clazz, sym);

});

}

codes[sym] = def;

}

function getMessage(key, args, self) {

const msg = messages.get(key);

if (assert === undefined) assert = require('internal/assert');

if (typeof msg === 'function') {

assert(

msg.length <= args.length, // Default options do not count.

`Code: ${key}; The provided arguments length (${args.length}) does not ` +

`match the required ones (${msg.length}).`

);

return msg.apply(self, args);

}

const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length;

assert(

expectedLength === args.length,

`Code: ${key}; The provided arguments length (${args.length}) does not ` +

`match the required ones (${expectedLength}).`

);

if (args.length === 0)

return msg;

ArrayPrototypeUnshift(args, msg);

return ReflectApply(lazyInternalUtilInspect().format, null, args);

}

let uvBinding;

function lazyUv() {

if (!uvBinding) {

uvBinding = internalBinding('uv');

}

return uvBinding;

}

const uvUnmappedError = ['UNKNOWN', 'unknown error'];

function uvErrmapGet(name) {

uvBinding = lazyUv();

if (!uvBinding.errmap) {

uvBinding.errmap = uvBinding.getErrorMap();

}

return uvBinding.errmap.get(name);

}

/**

* This creates an error compatible with errors produced in the C++

* function UVException using a context object with data assembled in C++.

* The goal is to migrate them to ERR_* errors later when compatibility is

* not a concern.

*

* @param {Object} ctx

* @returns {Error}

*/

function uvException(ctx) {

const [ code, uvmsg ] = uvErrmapGet(ctx.errno) || uvUnmappedError;

let message = `${code}: ${ctx.message || uvmsg}, ${ctx.syscall}`;

let path;

let dest;

if (ctx.path) {

path = ctx.path.toString();

message += ` '${path}'`;

}

if (ctx.dest) {

dest = ctx.dest.toString();

message += ` -> '${dest}'`;

}

// Reducing the limit improves the performance significantly. We do not loose

// the stack frames due to the `captureStackTrace()` function that is called

// later.

const tmpLimit = Error.stackTraceLimit;

Error.stackTraceLimit = 0;

// Pass the message to the constructor instead of setting it on the object

// to make sure it is the same as the one created in C++

// eslint-disable-next-line no-restricted-syntax

const err = new Error(message);

Error.stackTraceLimit = tmpLimit;

for (const prop of ObjectKeys(ctx)) {

if (prop === 'message' || prop === 'path' || prop === 'dest') {

continue;

}

err[prop] = ctx[prop];

}

err.code = code;

if (path) {

err.path = path;

}

if (dest) {

err.dest = dest;

}

ErrorCaptureStackTrace(err, excludedStackFn || uvException);

return err;

}

/**

* This creates an error compatible with errors produced in the C++

* This function should replace the deprecated

* `exceptionWithHostPort()` function.

*

* @param {number} err - A libuv error number

* @param {string} syscall

* @param {string} address

* @param {number} [port]

* @returns {Error}

*/

function uvExceptionWithHostPort(err, syscall, address, port) {

const [ code, uvmsg ] = uvErrmapGet(err) || uvUnmappedError;

const message = `${syscall} ${code}: ${uvmsg}`;

let details = '';

if (port && port > 0) {

details = ` ${address}:${port}`;

} else if (address) {

details = ` ${address}`;

}

// Reducing the limit improves the performance significantly. We do not loose

// the stack frames due to the `captureStackTrace()` function that is called

// later.

const tmpLimit = Error.stackTraceLimit;

Error.stackTraceLimit = 0;

// eslint-disable-next-line no-restricted-syntax

const ex = new Error(`${message}${details}`);

Error.stackTraceLimit = tmpLimit;

ex.code = code;

ex.errno = err;

ex.syscall = syscall;

ex.address = address;

if (port) {

ex.port = port;

}

ErrorCaptureStackTrace(ex, excludedStackFn || uvExceptionWithHostPort);

return ex;

}

/**

* This used to be util._errnoException().

*

* @param {number} err - A libuv error number

* @param {string} syscall

* @param {string} [original]

* @returns {Error}

*/

function errnoException(err, syscall, original) {

// TODO(joyeecheung): We have to use the type-checked

// getSystemErrorName(err) to guard against invalid arguments from users.

// This can be replaced with [ code ] = errmap.get(err) when this method

// is no longer exposed to user land.

if (util === undefined) util = require('util');

const code = util.getSystemErrorName(err);

const message = original ?

`${syscall} ${code} ${original}` : `${syscall} ${code}`;

// eslint-disable-next-line no-restricted-syntax

const ex = new Error(message);

ex.errno = err;

ex.code = code;

ex.syscall = syscall;

ErrorCaptureStackTrace(ex, excludedStackFn || errnoException);

return ex;

}

/**

* Deprecated, new function is `uvExceptionWithHostPort()`

* New function added the error description directly

* from C++. this method for backwards compatibility

* @param {number} err - A libuv error number

* @param {string} syscall

* @param {string} address

* @param {number} [port]

* @param {string} [additional]

* @returns {Error}

*/

function exceptionWithHostPort(err, syscall, address, port, additional) {

// TODO(joyeecheung): We have to use the type-checked

// getSystemErrorName(err) to guard against invalid arguments from users.

// This can be replaced with [ code ] = errmap.get(err) when this method

// is no longer exposed to user land.

if (util === undefined) util = require('util');

const code = util.getSystemErrorName(err);

let details = '';

if (port && port > 0) {

details = ` ${address}:${port}`;

} else if (address) {

details = ` ${address}`;

}

if (additional) {

details += ` - Local (${additional})`;

}

// Reducing the limit improves the performance significantly. We do not loose

// the stack frames due to the `captureStackTrace()` function that is called

// later.

const tmpLimit = Error.stackTraceLimit;

Error.stackTraceLimit = 0;

// eslint-disable-next-line no-restricted-syntax

const ex = new Error(`${syscall} ${code}${details}`);

Error.stackTraceLimit = tmpLimit;

ex.errno = err;

ex.code = code;

ex.syscall = syscall;

ex.address = address;

if (port) {

ex.port = port;

}

ErrorCaptureStackTrace(ex, excludedStackFn || exceptionWithHostPort);

return ex;

}

/**

* @param {number|string} code - A libuv error number or a c-ares error code

* @param {string} syscall

* @param {string} [hostname]

* @returns {Error}

*/

function dnsException(code, syscall, hostname) {

let errno;

// If `code` is of type number, it is a libuv error number, else it is a

// c-ares error code.

// TODO(joyeecheung): translate c-ares error codes into numeric ones and

// make them available in a property that's not error.errno (since they

// can be in conflict with libuv error codes). Also make sure

// util.getSystemErrorName() can understand them when an being informed that

// the number is a c-ares error code.

if (typeof code === 'number') {

errno = code;

// ENOTFOUND is not a proper POSIX error, but this error has been in place

// long enough that it's not practical to remove it.

if (code === lazyUv().UV_EAI_NODATA || code === lazyUv().UV_EAI_NONAME) {

code = 'ENOTFOUND'; // Fabricated error name.

} else {

code = lazyInternalUtil().getSystemErrorName(code);

}

}

const message = `${syscall} ${code}${hostname ? ` ${hostname}` : ''}`;

// Reducing the limit improves the performance significantly. We do not loose

// the stack frames due to the `captureStackTrace()` function that is called

// later.

const tmpLimit = Error.stackTraceLimit;

Error.stackTraceLimit = 0;

// eslint-disable-next-line no-restricted-syntax

const ex = new Error(message);

Error.stackTraceLimit = tmpLimit;

ex.errno = errno;

ex.code = code;

ex.syscall = syscall;

if (hostname) {

ex.hostname = hostname;

}

ErrorCaptureStackTrace(ex, excludedStackFn || dnsException);

return ex;

}

function connResetException(msg) {

// eslint-disable-next-line no-restricted-syntax

const ex = new Error(msg);

ex.code = 'ECONNRESET';

return ex;

}

let maxStack_ErrorName;

let maxStack_ErrorMessage;

/**

* Returns true if `err.name` and `err.message` are equal to engine-specific

* values indicating max call stack size has been exceeded.

* "Maximum call stack size exceeded" in V8.

*

* @param {Error} err

* @returns {boolean}

*/

function isStackOverflowError(err) {

if (maxStack_ErrorMessage === undefined) {

try {

function overflowStack() { overflowStack(); }

overflowStack();

} catch (err) {

maxStack_ErrorMessage = err.message;

maxStack_ErrorName = err.name;

}

}

return err && err.name === maxStack_ErrorName &&

err.message === maxStack_ErrorMessage;

}

// Only use this for integers! Decimal numbers do not work with this function.

function addNumericalSeparator(val) {

let res = '';

let i = val.length;

const start = val[0] === '-' ? 1 : 0;

for (; i >= start + 4; i -= 3) {

res = `_${StringPrototypeSlice(val, i - 3, i)}${res}`;

}

return `${StringPrototypeSlice(val, 0, i)}${res}`;

}

// Used to enhance the stack that will be picked up by the inspector

const kEnhanceStackBeforeInspector = Symbol('kEnhanceStackBeforeInspector');

// These are supposed to be called only on fatal exceptions before

// the process exits.

const fatalExceptionStackEnhancers = {

beforeInspector(error) {

if (typeof error[kEnhanceStackBeforeInspector] !== 'function') {

return error.stack;

}

try {

// Set the error.stack here so it gets picked up by the

// inspector.

error.stack = error[kEnhanceStackBeforeInspector]();

} catch {

// We are just enhancing the error. If it fails, ignore it.

}

return error.stack;

},

afterInspector(error) {

const originalStack = error.stack;

let useColors = true;

// Some consoles do not convert ANSI escape sequences to colors,

// rather display them directly to the stdout. On those consoles,

// libuv emulates colors by intercepting stdout stream and calling

// corresponding Windows API functions for setting console colors.

// However, fatal error are handled differently and we cannot easily

// highlight them. On Windows, detecting whether a console supports

// ANSI escape sequences is not reliable.

if (process.platform === 'win32') {

const info = internalBinding('os').getOSInformation();

const ver = ArrayPrototypeMap(StringPrototypeSplit(info[2], '.'),

Number);

if (ver[0] !== 10 || ver[2] < 14393) {

useColors = false;

}

}

const {

inspect,

inspectDefaultOptions: {

colors: defaultColors

}

} = lazyInternalUtilInspect();

const colors = useColors &&

((internalBinding('util').guessHandleType(2) === 'TTY' &&

require('internal/tty').hasColors()) ||

defaultColors);

try {

return inspect(error, {

colors,

customInspect: false,

depth: MathMax(inspect.defaultOptions.depth, 5)

});

} catch {

return originalStack;

}

}

};

module.exports = {

addCodeToName, // Exported for NghttpError

codes,

dnsException,

errnoException,

exceptionWithHostPort,

getMessage,

hideStackFrames,

isStackOverflowError,

connResetException,

uvErrmapGet,

uvException,

uvExceptionWithHostPort,

SystemError,

// This is exported only to facilitate testing.

E,

kNoOverride,

prepareStackTrace,

maybeOverridePrepareStackTrace,

overrideStackTrace,

kEnhanceStackBeforeInspector,

fatalExceptionStackEnhancers

};

// To declare an error message, use the E(sym, val, def) function above. The sym

// must be an upper case string. The val can be either a function or a string.

// The def must be an error class.

// The return value of the function must be a string.

// Examples:

// E('EXAMPLE_KEY1', 'This is the error value', Error);

// E('EXAMPLE_KEY2', (a, b) => return `${a} ${b}`, RangeError);

//

// Once an error code has been assigned, the code itself MUST NOT change and

// any given error code must never be reused to identify a different error.

//

// Any error code added here should also be added to the documentation

//

// Note: Please try to keep these in alphabetical order

//

// Note: Node.js specific errors must begin with the prefix ERR_

E('ERR_AMBIGUOUS_ARGUMENT', 'The "%s" argument is ambiguous. %s', TypeError);

E('ERR_ARG_NOT_ITERABLE', '%s must be iterable', TypeError);

E('ERR_ASSERTION', '%s', Error);

E('ERR_ASYNC_CALLBACK', '%s must be a function', TypeError);

E('ERR_ASYNC_TYPE', 'Invalid name for async "type": %s', TypeError);

E('ERR_BROTLI_INVALID_PARAM', '%s is not a valid Brotli parameter', RangeError);

E('ERR_BUFFER_OUT_OF_BOUNDS',

// Using a default argument here is important so the argument is not counted

// towards `Function#length`.

(name = undefined) => {

if (name) {

return `"${name}" is outside of buffer bounds`;

}

return 'Attempt to access memory outside buffer bounds';

}, RangeError);

E('ERR_BUFFER_TOO_LARGE',

'Cannot create a Buffer larger than %s bytes',

RangeError);

E('ERR_CANNOT_WATCH_SIGINT', 'Cannot watch for SIGINT signals', Error);

E('ERR_CHILD_CLOSED_BEFORE_REPLY',

'Child closed before reply received', Error);

E('ERR_CHILD_PROCESS_IPC_REQUIRED',

"Forked processes must have an IPC channel, missing value 'ipc' in %s",

Error);

E('ERR_CHILD_PROCESS_STDIO_MAXBUFFER', '%s maxBuffer length exceeded',

RangeError);

E('ERR_CONSOLE_WRITABLE_STREAM',

'Console expects a writable stream instance for %s', TypeError);

E('ERR_CONTEXT_NOT_INITIALIZED', 'context used is not initialized', Error);

E('ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED',

'Custom engines not supported by this OpenSSL', Error);

E('ERR_CRYPTO_ECDH_INVALID_FORMAT', 'Invalid ECDH format: %s', TypeError);

E('ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY',

'Public key is not valid for specified curve', Error);

E('ERR_CRYPTO_ENGINE_UNKNOWN', 'Engine "%s" was not found', Error);

E('ERR_CRYPTO_FIPS_FORCED',

'Cannot set FIPS mode, it was forced with --force-fips at startup.', Error);

E('ERR_CRYPTO_FIPS_UNAVAILABLE', 'Cannot set FIPS mode in a non-FIPS build.',

Error);

E('ERR_CRYPTO_HASH_FINALIZED', 'Digest already called', Error);

E('ERR_CRYPTO_HASH_UPDATE_FAILED', 'Hash update failed', Error);

E('ERR_CRYPTO_INCOMPATIBLE_KEY', 'Incompatible %s: %s', Error);

E('ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS', 'The selected key encoding %s %s.',

Error);

E('ERR_CRYPTO_INVALID_DIGEST', 'Invalid digest: %s', TypeError);

E('ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE',

'Invalid key object type %s, expected %s.', TypeError);

E('ERR_CRYPTO_INVALID_STATE', 'Invalid state for operation %s', Error);

E('ERR_CRYPTO_PBKDF2_ERROR', 'PBKDF2 error', Error);

E('ERR_CRYPTO_SCRYPT_INVALID_PARAMETER', 'Invalid scrypt parameter', Error);

E('ERR_CRYPTO_SCRYPT_NOT_SUPPORTED', 'Scrypt algorithm not supported', Error);

// Switch to TypeError. The current implementation does not seem right.

E('ERR_CRYPTO_SIGN_KEY_REQUIRED', 'No key provided to sign', Error);

E('ERR_DIR_CLOSED', 'Directory handle was closed', Error);

E('ERR_DIR_CONCURRENT_OPERATION',

'Cannot do synchronous work on directory handle with concurrent ' +

'asynchronous operations', Error);

E('ERR_DNS_SET_SERVERS_FAILED', 'c-ares failed to set servers: "%s" [%s]',

Error);

E('ERR_DOMAIN_CALLBACK_NOT_AVAILABLE',

'A callback was registered through ' +

'process.setUncaughtExceptionCaptureCallback(), which is mutually ' +

'exclusive with using the `domain` module',

Error);

E('ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE',

'The `domain` module is in use, which is mutually exclusive with calling ' +

'process.setUncaughtExceptionCaptureCallback()',

Error);

E('ERR_ENCODING_INVALID_ENCODED_DATA', function(encoding, ret) {

this.errno = ret;

return `The encoded data was not valid for encoding ${encoding}`;

}, TypeError);

E('ERR_ENCODING_NOT_SUPPORTED', 'The "%s" encoding is not supported',

RangeError);

E('ERR_EVAL_ESM_CANNOT_PRINT', '--print cannot be used with ESM input', Error);

E('ERR_EVENT_RECURSION', 'The event "%s" is already being dispatched', Error);

E('ERR_FALSY_VALUE_REJECTION', function(reason) {

this.reason = reason;

return 'Promise was rejected with falsy value';

}, Error);

E('ERR_FEATURE_UNAVAILABLE_ON_PLATFORM',

'The feature %s is unavailable on the current platform' +

', which is being used to run Node.js',

TypeError);

E('ERR_FS_EISDIR', 'Path is a directory', SystemError);

E('ERR_FS_FILE_TOO_LARGE', 'File size (%s) is greater than 2 GB', RangeError);

E('ERR_FS_INVALID_SYMLINK_TYPE',

'Symlink type must be one of "dir", "file", or "junction". Received "%s"',

Error); // Switch to TypeError. The current implementation does not seem right

E('ERR_HTTP2_ALTSVC_INVALID_ORIGIN',

'HTTP/2 ALTSVC frames require a valid origin', TypeError);

E('ERR_HTTP2_ALTSVC_LENGTH',

'HTTP/2 ALTSVC frames are limited to 16382 bytes', TypeError);

E('ERR_HTTP2_CONNECT_AUTHORITY',

':authority header is required for CONNECT requests', Error);

E('ERR_HTTP2_CONNECT_PATH',

'The :path header is forbidden for CONNECT requests', Error);

E('ERR_HTTP2_CONNECT_SCHEME',

'The :scheme header is forbidden for CONNECT requests', Error);

E('ERR_HTTP2_GOAWAY_SESSION',

'New streams cannot be created after receiving a GOAWAY', Error);

E('ERR_HTTP2_HEADERS_AFTER_RESPOND',

'Cannot specify additional headers after response initiated', Error);

E('ERR_HTTP2_HEADERS_SENT', 'Response has already been initiated.', Error);

E('ERR_HTTP2_HEADER_SINGLE_VALUE',

'Header field "%s" must only have a single value', TypeError);

E('ERR_HTTP2_INFO_STATUS_NOT_ALLOWED',

'Informational status codes cannot be used', RangeError);

E('ERR_HTTP2_INVALID_CONNECTION_HEADERS',

'HTTP/1 Connection specific headers are forbidden: "%s"', TypeError);

E('ERR_HTTP2_INVALID_HEADER_VALUE',

'Invalid value "%s" for header "%s"', TypeError);

E('ERR_HTTP2_INVALID_INFO_STATUS',

'Invalid informational status code: %s', RangeError);

E('ERR_HTTP2_INVALID_ORIGIN',

'HTTP/2 ORIGIN frames require a valid origin', TypeError);

E('ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH',

'Packed settings length must be a multiple of six', RangeError);

E('ERR_HTTP2_INVALID_PSEUDOHEADER',

'"%s" is an invalid pseudoheader or is used incorrectly', TypeError);

E('ERR_HTTP2_INVALID_SESSION', 'The session has been destroyed', Error);

E('ERR_HTTP2_INVALID_SETTING_VALUE',

// Using default arguments here is important so the arguments are not counted

// towards `Function#length`.

function(name, actual, min = undefined, max = undefined) {

this.actual = actual;

if (min !== undefined) {

this.min = min;

this.max = max;

}

return `Invalid value for setting "${name}": ${actual}`;

}, TypeError, RangeError);

E('ERR_HTTP2_INVALID_STREAM', 'The stream has been destroyed', Error);

E('ERR_HTTP2_MAX_PENDING_SETTINGS_ACK',

'Maximum number of pending settings acknowledgements', Error);

E('ERR_HTTP2_NESTED_PUSH',

'A push stream cannot initiate another push stream.', Error);

E('ERR_HTTP2_NO_MEM', 'Out of memory', Error);

E('ERR_HTTP2_NO_SOCKET_MANIPULATION',

'HTTP/2 sockets should not be directly manipulated (e.g. read and written)',

Error);

E('ERR_HTTP2_ORIGIN_LENGTH',

'HTTP/2 ORIGIN frames are limited to 16382 bytes', TypeError);

E('ERR_HTTP2_OUT_OF_STREAMS',

'No stream ID is available because maximum stream ID has been reached',

Error);

E('ERR_HTTP2_PAYLOAD_FORBIDDEN',

'Responses with %s status must not have a payload', Error);

E('ERR_HTTP2_PING_CANCEL', 'HTTP2 ping cancelled', Error);

E('ERR_HTTP2_PING_LENGTH', 'HTTP2 ping payload must be 8 bytes', RangeError);

E('ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED',

'Cannot set HTTP/2 pseudo-headers', TypeError);

E('ERR_HTTP2_PUSH_DISABLED', 'HTTP/2 client has disabled push streams', Error);

E('ERR_HTTP2_SEND_FILE', 'Directories cannot be sent', Error);

E('ERR_HTTP2_SEND_FILE_NOSEEK',

'Offset or length can only be specified for regular files', Error);

E('ERR_HTTP2_SESSION_ERROR', 'Session closed with error code %s', Error);

E('ERR_HTTP2_SETTINGS_CANCEL', 'HTTP2 session settings canceled', Error);

E('ERR_HTTP2_SOCKET_BOUND',

'The socket is already bound to an Http2Session', Error);

E('ERR_HTTP2_SOCKET_UNBOUND',

'The socket has been disconnected from the Http2Session', Error);

E('ERR_HTTP2_STATUS_101',

'HTTP status code 101 (Switching Protocols) is forbidden in HTTP/2', Error);

E('ERR_HTTP2_STATUS_INVALID', 'Invalid status code: %s', RangeError);

E('ERR_HTTP2_STREAM_CANCEL', function(error) {

let msg = 'The pending stream has been canceled';

if (error) {

this.cause = error;

if (typeof error.message === 'string')

msg += ` (caused by: ${error.message})`;

}

return msg;

}, Error);

E('ERR_HTTP2_STREAM_ERROR', 'Stream closed with error code %s', Error);

E('ERR_HTTP2_STREAM_SELF_DEPENDENCY',

'A stream cannot depend on itself', Error);

E('ERR_HTTP2_TRAILERS_ALREADY_SENT',

'Trailing headers have already been sent', Error);

E('ERR_HTTP2_TRAILERS_NOT_READY',

'Trailing headers cannot be sent until after the wantTrailers event is ' +

'emitted', Error);

E('ERR_HTTP2_UNSUPPORTED_PROTOCOL', 'protocol "%s" is unsupported.', Error);

E('ERR_HTTP_HEADERS_SENT',

'Cannot %s headers after they are sent to the client', Error);

E('ERR_HTTP_INVALID_HEADER_VALUE',

'Invalid value "%s" for header "%s"', TypeError);

E('ERR_HTTP_INVALID_STATUS_CODE', 'Invalid status code: %s', RangeError);

E('ERR_HTTP_REQUEST_TIMEOUT', 'Request timeout', Error);

E('ERR_HTTP_SOCKET_ENCODING',

'Changing the socket encoding is not allowed per RFC7230 Section 3.', Error);

E('ERR_HTTP_TRAILER_INVALID',

'Trailers are invalid with this transfer encoding', Error);

E('ERR_INCOMPATIBLE_OPTION_PAIR',

'Option "%s" cannot be used in combination with option "%s"', TypeError);

E('ERR_INPUT_TYPE_NOT_ALLOWED', '--input-type can only be used with string ' +

'input via --eval, --print, or STDIN', Error);

E('ERR_INSPECTOR_ALREADY_ACTIVATED',

'Inspector is already activated. Close it with inspector.close() ' +

'before activating it again.',

Error);

E('ERR_INSPECTOR_ALREADY_CONNECTED', '%s is already connected', Error);

E('ERR_INSPECTOR_CLOSED', 'Session was closed', Error);

E('ERR_INSPECTOR_COMMAND', 'Inspector error %d: %s', Error);

E('ERR_INSPECTOR_NOT_ACTIVE', 'Inspector is not active', Error);

E('ERR_INSPECTOR_NOT_AVAILABLE', 'Inspector is not available', Error);

E('ERR_INSPECTOR_NOT_CONNECTED', 'Session is not connected', Error);

E('ERR_INSPECTOR_NOT_WORKER', 'Current thread is not a worker', Error);

E('ERR_INTERNAL_ASSERTION', (message) => {

const suffix = 'This is caused by either a bug in Node.js ' +

'or incorrect usage of Node.js internals.\n' +

'Please open an issue with this stack trace at ' +

'https://github.com/nodejs/node/issues\n';

return message === undefined ? suffix : `${message}\n${suffix}`;

}, Error);

E('ERR_INVALID_ADDRESS_FAMILY', function(addressType, host, port) {

this.host = host;

this.port = port;

return `Invalid address family: ${addressType} ${host}:${port}`;

}, RangeError);

E('ERR_INVALID_ARG_TYPE',

(name, expected, actual) => {

assert(typeof name === 'string', "'name' must be a string");

if (!ArrayIsArray(expected)) {

expected = [expected];

}

let msg = 'The ';

if (StringPrototypeEndsWith(name, ' argument')) {

// For cases like 'first argument'

msg += `${name} `;