/* 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 {

AggregateError,

ArrayFrom,

ArrayIsArray,

ArrayPrototypeFilter,

ArrayPrototypeIncludes,

ArrayPrototypeIndexOf,

ArrayPrototypeJoin,

ArrayPrototypeMap,

ArrayPrototypePush,

ArrayPrototypeSlice,

ArrayPrototypeSplice,

ArrayPrototypeUnshift,

Error,

ErrorCaptureStackTrace,

ErrorPrototypeToString,

JSONStringify,

MapPrototypeGet,

MathAbs,

MathMax,

Number,

NumberIsInteger,

ObjectAssign,

ObjectDefineProperty,

ObjectDefineProperties,

ObjectIsExtensible,

ObjectGetOwnPropertyDescriptor,

ObjectKeys,

ObjectPrototypeHasOwnProperty,

RangeError,

ReflectApply,

RegExpPrototypeExec,

SafeArrayIterator,

SafeMap,

SafeWeakMap,

String,

StringPrototypeEndsWith,

StringPrototypeIncludes,

StringPrototypeSlice,

StringPrototypeSplit,

StringPrototypeStartsWith,

StringPrototypeToLowerCase,

Symbol,

SymbolFor,

SyntaxError,

TypeError,

URIError,

} = primordials;

const kIsNodeError = Symbol('kIsNodeError');

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

const messages = new SafeMap();

const codes = {};

const classRegExp = /^[A-Z][a-zA-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');

let userStackTraceLimit;

const nodeInternalPrefix = '__node_internal_';

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 firstFrame = trace[0]?.getFunctionName();

if (firstFrame && StringPrototypeStartsWith(firstFrame, nodeInternalPrefix)) {

for (let l = trace.length - 1; l >= 0; l--) {

const fn = trace[l]?.getFunctionName();

if (fn && StringPrototypeStartsWith(fn, nodeInternalPrefix)) {

ArrayPrototypeSplice(trace, 0, l + 1);

break;

}

}

// `userStackTraceLimit` is the user value for `Error.stackTraceLimit`,

// it is updated at every new exception in `captureLargerStackTrace`.

if (trace.length > userStackTraceLimit)

ArrayPrototypeSplice(trace, userStackTraceLimit);

}

const globalOverride =

maybeOverridePrepareStackTrace(globalThis, error, trace);

if (globalOverride !== kNoOverride) return globalOverride;

// Normal error formatting:

//

// Error: Message

// at function (file)

// at file

let errorString;

if (kIsNodeError in error) {

errorString = `${error.name} [${error.code}]: ${error.message}`;

} else {

errorString = ErrorPrototypeToString(error);

}

if (trace.length === 0) {

return errorString;

}

return `${errorString}\n at ${ArrayPrototypeJoin(trace, '\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;

};

const aggregateTwoErrors = hideStackFrames((innerError, outerError) => {

if (innerError && outerError && innerError !== outerError) {

if (ArrayIsArray(outerError.errors)) {

// If `outerError` is already an `AggregateError`.

ArrayPrototypePush(outerError.errors, innerError);

return outerError;

}

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

const err = new AggregateError(new SafeArrayIterator([

outerError,

innerError,

]), outerError.message);

err.code = outerError.code;

return err;

}

return innerError || outerError;

});

const aggregateErrors = hideStackFrames((errors, message, code) => {

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

const err = new AggregateError(new SafeArrayIterator(errors), message);

err.code = errors[0]?.code;

return err;

});

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

// Lazily loaded

let util;

let internalUtil = null;

function lazyInternalUtil() {

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

return internalUtil;

}

let internalUtilInspect = null;

function lazyInternalUtilInspect() {

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

return internalUtilInspect;

}

let utilColors;

function lazyUtilColors() {

utilColors ??= require('internal/util/colors');

return utilColors;

}

let buffer;

function lazyBuffer() {

buffer ??= require('buffer').Buffer;

return buffer;

}

function isErrorStackTraceLimitWritable() {

// Do no touch Error.stackTraceLimit as V8 would attempt to install

// it again during deserialization.

if (require('internal/v8/startup_snapshot').namespace.isBuildingSnapshot()) {

return false;

}

const desc = ObjectGetOwnPropertyDescriptor(Error, 'stackTraceLimit');

if (desc === undefined) {

return ObjectIsExtensible(Error);

}

return ObjectPrototypeHasOwnProperty(desc, 'writable') ?

desc.writable :

desc.set !== undefined;

}

function inspectWithNoCustomRetry(obj, options) {

const utilInspect = lazyInternalUtilInspect();

try {

return utilInspect.inspect(obj, options);

} catch {

return utilInspect.inspect(obj, { ...options, customInspect: false });

}

}

// 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) {

const limit = Error.stackTraceLimit;

if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;

super();

// Reset the limit and setting the name property.

if (isErrorStackTraceLimitWritable()) 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}`;

captureLargerStackTrace(this);

this.code = key;

ObjectDefineProperties(this, {

[kIsNodeError]: {

__proto__: null,

value: true,

enumerable: false,

writable: false,

configurable: true,

},

name: {

__proto__: null,

value: 'SystemError',

enumerable: false,

writable: true,

configurable: true,

},

message: {

__proto__: null,

value: message,

enumerable: false,

writable: true,

configurable: true,

},

info: {

__proto__: null,

value: context,

enumerable: true,

configurable: true,

writable: false,

},

errno: {

__proto__: null,

get() {

return context.errno;

},

set: (value) => {

context.errno = value;

},

enumerable: true,

configurable: true,

},

syscall: {

__proto__: null,

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', {

__proto__: null,

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', {

__proto__: null,

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

const msg = messages.get(key);

const expectedLength = typeof msg !== 'string' ? -1 : getExpectedArgumentLength(msg);

switch (expectedLength) {

case 0: {

class NodeError extends Base {

code = key;

constructor(...args) {

assert(

args.length === 0,

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

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

);

super(msg);

}

// This is a workaround for wpt tests that expect that the error

// constructor has a `name` property of the base class.

get ['constructor']() {

return Base;

}

get [kIsNodeError]() {

return true;

}

toString() {

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

}

}

return NodeError;

}

case -1: {

class NodeError extends Base {

code = key;

constructor(...args) {

super();

ObjectDefineProperty(this, 'message', {

__proto__: null,

value: getMessage(key, args, this),

enumerable: false,

writable: true,

configurable: true,

});

}

// This is a workaround for wpt tests that expect that the error

// constructor has a `name` property of the base class.

get ['constructor']() {

return Base;

}

get [kIsNodeError]() {

return true;

}

toString() {

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

}

}

return NodeError;

}

default: {

class NodeError extends Base {

code = key;

constructor(...args) {

assert(

args.length === expectedLength,

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

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

);

ArrayPrototypeUnshift(args, msg);

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

}

// This is a workaround for wpt tests that expect that the error

// constructor has a `name` property of the base class.

get ['constructor']() {

return Base;

}

get [kIsNodeError]() {

return true;

}

toString() {

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

}

}

return NodeError;

}

}

}

/**

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

* @template {(...args: unknown[]) => unknown} T

* @param {T} fn

* @returns {T}

*/

function hideStackFrames(fn) {

// We rename the functions that will be hidden to cut off the stacktrace

// at the outermost one

const hidden = nodeInternalPrefix + fn.name;

ObjectDefineProperty(fn, 'name', { __proto__: null, value: hidden });

return fn;

}

// 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 getExpectedArgumentLength(msg) {

let expectedLength = 0;

const regex = /%[dfijoOs]/g;

while (RegExpPrototypeExec(regex, msg) !== null) expectedLength++;

return expectedLength;

}

function getMessage(key, args, self) {

const msg = messages.get(key);

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 ReflectApply(msg, self, args);

}

const expectedLength = getExpectedArgumentLength(msg);

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() {

uvBinding ??= internalBinding('uv');

return uvBinding;

}

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

function uvErrmapGet(name) {

uvBinding = lazyUv();

uvBinding.errmap ??= uvBinding.getErrorMap();

return MapPrototypeGet(uvBinding.errmap, name);

}

const captureLargerStackTrace = hideStackFrames(

function captureLargerStackTrace(err) {

const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();

if (stackTraceLimitIsWritable) {

userStackTraceLimit = Error.stackTraceLimit;

Error.stackTraceLimit = Infinity;

}

ErrorCaptureStackTrace(err);

// Reset the limit

if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;

return err;

});

/**

* 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}

*/

const uvException = hideStackFrames(function uvException(ctx) {

const { 0: code, 1: 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 lose

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

// later.

const tmpLimit = Error.stackTraceLimit;

if (isErrorStackTraceLimitWritable()) 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);

if (isErrorStackTraceLimitWritable()) 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;

}

return captureLargerStackTrace(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}

*/

const uvExceptionWithHostPort = hideStackFrames(

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

const { 0: code, 1: 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

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

// is called later.

const tmpLimit = Error.stackTraceLimit;

if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;

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

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

if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = tmpLimit;

ex.code = code;

ex.errno = err;

ex.syscall = syscall;

ex.address = address;

if (port) {

ex.port = port;

}

return captureLargerStackTrace(ex);

});

/**

* This used to be util._errnoException().

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

* @param {string} syscall

* @param {string} [original]

* @returns {Error}

*/

const errnoException = hideStackFrames(

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.

util ??= require('util');

const code = util.getSystemErrorName(err);

const message = original ?

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

const tmpLimit = Error.stackTraceLimit;

if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;

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

const ex = new Error(message);

if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = tmpLimit;

ex.errno = err;

ex.code = code;

ex.syscall = syscall;

return captureLargerStackTrace(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}

*/

const exceptionWithHostPort = hideStackFrames(

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.

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

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

// is called later.

const tmpLimit = Error.stackTraceLimit;

if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;

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

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

if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = tmpLimit;

ex.errno = err;

ex.code = code;

ex.syscall = syscall;

ex.address = address;

if (port) {

ex.port = port;

}

return captureLargerStackTrace(ex);

});

/**

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

* @param {string} syscall

* @param {string} [hostname]

* @returns {Error}

*/

const dnsException = hideStackFrames(function(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 lose

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

// later.

const tmpLimit = Error.stackTraceLimit;

if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;

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

const ex = new Error(message);

if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = tmpLimit;

ex.errno = errno;

ex.code = code;

ex.syscall = syscall;

if (hostname) {

ex.hostname = hostname;

}

return captureLargerStackTrace(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 (isWindows) {

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 && (lazyUtilColors().shouldColorize(process.stderr) || defaultColors);

try {

return inspect(error, {

colors,

customInspect: false,

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

});

} catch {

return originalStack;

}

},

};

const {

privateSymbols: {

arrow_message_private_symbol,

},

} = internalBinding('util');

// Ensures the printed error line is from user code.

function setArrowMessage(err, arrowMessage) {

err[arrow_message_private_symbol] = arrowMessage;

}

// Hide stack lines before the first user code line.

function hideInternalStackFrames(error) {

overrideStackTrace.set(error, (error, stackFrames) => {

let frames = stackFrames;

if (typeof stackFrames === 'object') {

frames = ArrayPrototypeFilter(

stackFrames,

(frm) => !StringPrototypeStartsWith(frm.getFileName() || '',

'node:internal'),

);

}

ArrayPrototypeUnshift(frames, error);

return ArrayPrototypeJoin(frames, '\n at ');

});

}

// Node uses an AbortError that isn't exactly the same as the DOMException

// to make usage of the error in userland and readable-stream easier.

// It is a regular error with `.code` and `.name`.

class AbortError extends Error {

constructor(message = 'The operation was aborted', options = undefined) {

if (options !== undefined && typeof options !== 'object') {

throw new codes.ERR_INVALID_ARG_TYPE('options', 'Object', options);

}

super(message, options);

this.code = 'ABORT_ERR';

this.name = 'AbortError';

}

}

/**

* This creates a generic Node.js error.

* @param {string} message The error message.

* @param {object} errorProperties Object with additional properties to be added to the error.

* @returns {Error}

*/

const genericNodeError = hideStackFrames(function genericNodeError(message, errorProperties) {

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

const err = new Error(message);

ObjectAssign(err, errorProperties);

return err;

});

/**

* Determine the specific type of a value for type-mismatch errors.

* @param {*} value

* @returns {string}

*/

function determineSpecificType(value) {

if (value == null) {

return '' + value;

}

if (typeof value === 'function' && value.name) {

return `function ${value.name}`;

}

if (typeof value === 'object') {

if (value.constructor?.name) {

return `an instance of ${value.constructor.name}`;

}

return `${lazyInternalUtilInspect().inspect(value, { depth: -1 })}`;

}

let inspected = lazyInternalUtilInspect()

.inspect(value, { colors: false });

if (inspected.length > 28) { inspected = `${StringPrototypeSlice(inspected, 0, 25)}...`; }

return `type ${typeof value} (${inspected})`;

}

/**

* Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.

* We cannot use Intl.ListFormat because it's not available in

* --without-intl builds.

* @param {string[]} array An array of strings.

* @param {string} [type] The list type to be inserted before the last element.

* @returns {string}

*/

function formatList(array, type = 'and') {

switch (array.length) {

case 0: return '';

case 1: return `${array[0]}`;

case 2: return `${array[0]} ${type} ${array[1]}`;

case 3: return `${array[0]}, ${array[1]}, ${type} ${array[2]}`;

default:

return `${ArrayPrototypeJoin(ArrayPrototypeSlice(array, 0, -1), ', ')}, ${type} ${array[array.length - 1]}`;

}

}

module.exports = {

AbortError,

aggregateTwoErrors,

aggregateErrors,

captureLargerStackTrace,

codes,

connResetException,

dnsException,

// This is exported only to facilitate testing.

determineSpecificType,

E,

errnoException,

exceptionWithHostPort,

fatalExceptionStackEnhancers,

formatList,

genericNodeError,

getMessage,

hideInternalStackFrames,

hideStackFrames,

inspectWithNoCustomRetry,

isErrorStackTraceLimitWritable,