'use strict'

const kUndiciError = Symbol.for('undici.error.UND_ERR')

class UndiciError extends Error {

constructor (message, options) {

super(message, options)

this.name = 'UndiciError'

this.code = 'UND_ERR'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kUndiciError] === true

}

get [kUndiciError] () {

return true

}

}

const kConnectTimeoutError = Symbol.for('undici.error.UND_ERR_CONNECT_TIMEOUT')

class ConnectTimeoutError extends UndiciError {

constructor (message) {

super(message)

this.name = 'ConnectTimeoutError'

this.message = message || 'Connect Timeout Error'

this.code = 'UND_ERR_CONNECT_TIMEOUT'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kConnectTimeoutError] === true

}

get [kConnectTimeoutError] () {

return true

}

}

const kHeadersTimeoutError = Symbol.for('undici.error.UND_ERR_HEADERS_TIMEOUT')

class HeadersTimeoutError extends UndiciError {

constructor (message) {

super(message)

this.name = 'HeadersTimeoutError'

this.message = message || 'Headers Timeout Error'

this.code = 'UND_ERR_HEADERS_TIMEOUT'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kHeadersTimeoutError] === true

}

get [kHeadersTimeoutError] () {

return true

}

}

const kHeadersOverflowError = Symbol.for('undici.error.UND_ERR_HEADERS_OVERFLOW')

class HeadersOverflowError extends UndiciError {

constructor (message) {

super(message)

this.name = 'HeadersOverflowError'

this.message = message || 'Headers Overflow Error'

this.code = 'UND_ERR_HEADERS_OVERFLOW'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kHeadersOverflowError] === true

}

get [kHeadersOverflowError] () {

return true

}

}

const kBodyTimeoutError = Symbol.for('undici.error.UND_ERR_BODY_TIMEOUT')

class BodyTimeoutError extends UndiciError {

constructor (message) {

super(message)

this.name = 'BodyTimeoutError'

this.message = message || 'Body Timeout Error'

this.code = 'UND_ERR_BODY_TIMEOUT'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kBodyTimeoutError] === true

}

get [kBodyTimeoutError] () {

return true

}

}

const kInvalidArgumentError = Symbol.for('undici.error.UND_ERR_INVALID_ARG')

class InvalidArgumentError extends UndiciError {

constructor (message) {

super(message)

this.name = 'InvalidArgumentError'

this.message = message || 'Invalid Argument Error'

this.code = 'UND_ERR_INVALID_ARG'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kInvalidArgumentError] === true

}

get [kInvalidArgumentError] () {

return true

}

}

const kInvalidReturnValueError = Symbol.for('undici.error.UND_ERR_INVALID_RETURN_VALUE')

class InvalidReturnValueError extends UndiciError {

constructor (message) {

super(message)

this.name = 'InvalidReturnValueError'

this.message = message || 'Invalid Return Value Error'

this.code = 'UND_ERR_INVALID_RETURN_VALUE'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kInvalidReturnValueError] === true

}

get [kInvalidReturnValueError] () {

return true

}

}

const kAbortError = Symbol.for('undici.error.UND_ERR_ABORT')

class AbortError extends UndiciError {

constructor (message) {

super(message)

this.name = 'AbortError'

this.message = message || 'The operation was aborted'

this.code = 'UND_ERR_ABORT'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kAbortError] === true

}

get [kAbortError] () {

return true

}

}

const kRequestAbortedError = Symbol.for('undici.error.UND_ERR_ABORTED')

class RequestAbortedError extends AbortError {

constructor (message) {

super(message)

this.name = 'AbortError'

this.message = message || 'Request aborted'

this.code = 'UND_ERR_ABORTED'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kRequestAbortedError] === true

}

get [kRequestAbortedError] () {

return true

}

}

const kInformationalError = Symbol.for('undici.error.UND_ERR_INFO')

class InformationalError extends UndiciError {

constructor (message, options) {

super(message, options)

this.name = 'InformationalError'

this.message = message || 'Request information'

this.code = 'UND_ERR_INFO'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kInformationalError] === true

}

get [kInformationalError] () {

return true

}

}

const kRequestContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH')

class RequestContentLengthMismatchError extends UndiciError {

constructor (message) {

super(message)

this.name = 'RequestContentLengthMismatchError'

this.message = message || 'Request body length does not match content-length header'

this.code = 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kRequestContentLengthMismatchError] === true

}

get [kRequestContentLengthMismatchError] () {

return true

}

}

const kResponseContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH')

class ResponseContentLengthMismatchError extends UndiciError {

constructor (message) {

super(message)

this.name = 'ResponseContentLengthMismatchError'

this.message = message || 'Response body length does not match content-length header'

this.code = 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kResponseContentLengthMismatchError] === true

}

get [kResponseContentLengthMismatchError] () {

return true

}

}

const kClientDestroyedError = Symbol.for('undici.error.UND_ERR_DESTROYED')

class ClientDestroyedError extends UndiciError {

constructor (message) {

super(message)

this.name = 'ClientDestroyedError'

this.message = message || 'The client is destroyed'

this.code = 'UND_ERR_DESTROYED'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kClientDestroyedError] === true

}

get [kClientDestroyedError] () {

return true

}

}

const kClientClosedError = Symbol.for('undici.error.UND_ERR_CLOSED')

class ClientClosedError extends UndiciError {

constructor (message) {

super(message)

this.name = 'ClientClosedError'

this.message = message || 'The client is closed'

this.code = 'UND_ERR_CLOSED'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kClientClosedError] === true

}

get [kClientClosedError] () {

return true

}

}

const kSocketError = Symbol.for('undici.error.UND_ERR_SOCKET')

class SocketError extends UndiciError {

constructor (message, socket) {

super(message)

this.name = 'SocketError'

this.message = message || 'Socket error'

this.code = 'UND_ERR_SOCKET'

this.socket = socket

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kSocketError] === true

}

get [kSocketError] () {

return true

}

}

const kNotSupportedError = Symbol.for('undici.error.UND_ERR_NOT_SUPPORTED')

class NotSupportedError extends UndiciError {

constructor (message) {

super(message)

this.name = 'NotSupportedError'

this.message = message || 'Not supported error'

this.code = 'UND_ERR_NOT_SUPPORTED'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kNotSupportedError] === true

}

get [kNotSupportedError] () {

return true

}

}

const kBalancedPoolMissingUpstreamError = Symbol.for('undici.error.UND_ERR_BPL_MISSING_UPSTREAM')

class BalancedPoolMissingUpstreamError extends UndiciError {

constructor (message) {

super(message)

this.name = 'MissingUpstreamError'

this.message = message || 'No upstream has been added to the BalancedPool'

this.code = 'UND_ERR_BPL_MISSING_UPSTREAM'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kBalancedPoolMissingUpstreamError] === true

}

get [kBalancedPoolMissingUpstreamError] () {

return true

}

}

const kHTTPParserError = Symbol.for('undici.error.UND_ERR_HTTP_PARSER')

class HTTPParserError extends Error {

constructor (message, code, data) {

super(message)

this.name = 'HTTPParserError'

this.code = code ? `HPE_${code}` : undefined

this.data = data ? data.toString() : undefined

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kHTTPParserError] === true

}

get [kHTTPParserError] () {

return true

}

}

const kResponseExceededMaxSizeError = Symbol.for('undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE')

class ResponseExceededMaxSizeError extends UndiciError {

constructor (message) {

super(message)

this.name = 'ResponseExceededMaxSizeError'

this.message = message || 'Response content exceeded max size'

this.code = 'UND_ERR_RES_EXCEEDED_MAX_SIZE'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kResponseExceededMaxSizeError] === true

}

get [kResponseExceededMaxSizeError] () {

return true

}

}

const kRequestRetryError = Symbol.for('undici.error.UND_ERR_REQ_RETRY')

class RequestRetryError extends UndiciError {

constructor (message, code, { headers, data }) {

super(message)

this.name = 'RequestRetryError'

this.message = message || 'Request retry error'

this.code = 'UND_ERR_REQ_RETRY'

this.statusCode = code

this.data = data

this.headers = headers

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kRequestRetryError] === true

}

get [kRequestRetryError] () {

return true

}

}

const kResponseError = Symbol.for('undici.error.UND_ERR_RESPONSE')

class ResponseError extends UndiciError {

constructor (message, code, { headers, body }) {

super(message)

this.name = 'ResponseError'

this.message = message || 'Response error'

this.code = 'UND_ERR_RESPONSE'

this.statusCode = code

this.body = body

this.headers = headers

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kResponseError] === true

}

get [kResponseError] () {

return true

}

}

const kSecureProxyConnectionError = Symbol.for('undici.error.UND_ERR_PRX_TLS')

class SecureProxyConnectionError extends UndiciError {

constructor (cause, message, options = {}) {

super(message, { cause, ...options })

this.name = 'SecureProxyConnectionError'

this.message = message || 'Secure Proxy Connection failed'

this.code = 'UND_ERR_PRX_TLS'

this.cause = cause

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kSecureProxyConnectionError] === true

}

get [kSecureProxyConnectionError] () {

return true

}

}

const kMaxOriginsReachedError = Symbol.for('undici.error.UND_ERR_MAX_ORIGINS_REACHED')

class MaxOriginsReachedError extends UndiciError {

constructor (message) {

super(message)

this.name = 'MaxOriginsReachedError'

this.message = message || 'Maximum allowed origins reached'

this.code = 'UND_ERR_MAX_ORIGINS_REACHED'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kMaxOriginsReachedError] === true

}

get [kMaxOriginsReachedError] () {

return true

}

}

class Socks5ProxyError extends UndiciError {

constructor (message, code) {

super(message)

this.name = 'Socks5ProxyError'

this.message = message || 'SOCKS5 proxy error'

this.code = code || 'UND_ERR_SOCKS5'

}

}

const kMessageSizeExceededError = Symbol.for('undici.error.UND_ERR_WS_MESSAGE_SIZE_EXCEEDED')

class MessageSizeExceededError extends UndiciError {

constructor (message) {

super(message)

this.name = 'MessageSizeExceededError'

this.message = message || 'Max decompressed message size exceeded'

this.code = 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED'

}

static [Symbol.hasInstance] (instance) {

return instance && instance[kMessageSizeExceededError] === true

}

get [kMessageSizeExceededError] () {

return true

}

}

module.exports = {

AbortError,

HTTPParserError,

UndiciError,

HeadersTimeoutError,

HeadersOverflowError,

BodyTimeoutError,

RequestContentLengthMismatchError,

ConnectTimeoutError,

InvalidArgumentError,

InvalidReturnValueError,

RequestAbortedError,

ClientDestroyedError,

ClientClosedError,

InformationalError,

SocketError,

NotSupportedError,

ResponseContentLengthMismatchError,

BalancedPoolMissingUpstreamError,

ResponseExceededMaxSizeError,

RequestRetryError,

ResponseError,

SecureProxyConnectionError,

MaxOriginsReachedError,

Socks5ProxyError,

MessageSizeExceededError

}