From 355d5d3bba1ddcd6a11c786f8aee2b349538e048 Mon Sep 17 00:00:00 2001 From: Steven Guerrero Date: Tue, 24 Nov 2020 16:11:16 -0500 Subject: [PATCH] feat(std/node): Port most of node errors (#7934) --- std/node/_errors.ts | 1789 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1788 insertions(+), 1 deletion(-) diff --git a/std/node/_errors.ts b/std/node/_errors.ts index 1fcd4a2fa0..2424303b14 100644 --- a/std/node/_errors.ts +++ b/std/node/_errors.ts @@ -5,7 +5,6 @@ * ERR_INVALID_PACKAGE_TARGET * ERR_INVALID_URL_SCHEME * ERR_MANIFEST_ASSERT_INTEGRITY -* ERR_MISSING_ARGS * ERR_MODULE_NOT_FOUND * ERR_PACKAGE_PATH_NOT_EXPORTED * ERR_QUICSESSION_VERSION_NEGOTIATION @@ -111,6 +110,342 @@ export class ERR_OUT_OF_RANGE extends RangeError { } } +export class ERR_AMBIGUOUS_ARGUMENT extends NodeTypeError { + constructor(x: string, y: string) { + super("ERR_AMBIGUOUS_ARGUMENT", `The "${x}" argument is ambiguous. ${y}`); + } +} + +export class ERR_ARG_NOT_ITERABLE extends NodeTypeError { + constructor(x: string) { + super("ERR_ARG_NOT_ITERABLE", `${x} must be iterable`); + } +} + +export class ERR_ASSERTION extends NodeError { + constructor(x: string) { + super("ERR_ASSERTION", `${x}`); + } +} + +export class ERR_ASYNC_CALLBACK extends NodeTypeError { + constructor(x: string) { + super("ERR_ASYNC_CALLBACK", `${x} must be a function`); + } +} + +export class ERR_ASYNC_TYPE extends NodeTypeError { + constructor(x: string) { + super("ERR_ASYNC_TYPE", `Invalid name for async "type": ${x}`); + } +} + +export class ERR_BROTLI_INVALID_PARAM extends NodeRangeError { + constructor(x: string) { + super("ERR_BROTLI_INVALID_PARAM", `${x} is not a valid Brotli parameter`); + } +} + +export class ERR_BUFFER_OUT_OF_BOUNDS extends NodeRangeError { + constructor(name?: string) { + super( + "ERR_BUFFER_OUT_OF_BOUNDS", + name + ? `"${name}" is outside of buffer bounds` + : "Attempt to access memory outside buffer bounds", + ); + } +} + +export class ERR_BUFFER_TOO_LARGE extends NodeRangeError { + constructor(x: string) { + super( + "ERR_BUFFER_TOO_LARGE", + `Cannot create a Buffer larger than ${x} bytes`, + ); + } +} + +export class ERR_CANNOT_WATCH_SIGINT extends NodeError { + constructor() { + super( + "ERR_CANNOT_WATCH_SIGINT", + "Cannot watch for SIGINT signals", + ); + } +} + +export class ERR_CHILD_CLOSED_BEFORE_REPLY extends NodeError { + constructor() { + super( + "ERR_CHILD_CLOSED_BEFORE_REPLY", + "Child closed before reply received", + ); + } +} + +export class ERR_CHILD_PROCESS_IPC_REQUIRED extends NodeError { + constructor(x: string) { + super( + "ERR_CHILD_PROCESS_IPC_REQUIRED", + `Forked processes must have an IPC channel, missing value 'ipc' in ${x}`, + ); + } +} + +export class ERR_CHILD_PROCESS_STDIO_MAXBUFFER extends NodeRangeError { + constructor(x: string) { + super( + "ERR_CHILD_PROCESS_STDIO_MAXBUFFER", + `${x} maxBuffer length exceeded`, + ); + } +} + +export class ERR_CONSOLE_WRITABLE_STREAM extends NodeTypeError { + constructor(x: string) { + super( + "ERR_CONSOLE_WRITABLE_STREAM", + `Console expects a writable stream instance for ${x}`, + ); + } +} + +export class ERR_CONTEXT_NOT_INITIALIZED extends NodeError { + constructor() { + super( + "ERR_CONTEXT_NOT_INITIALIZED", + "context used is not initialized", + ); + } +} + +export class ERR_CPU_USAGE extends NodeError { + constructor(x: string) { + super( + "ERR_CPU_USAGE", + `Unable to obtain cpu usage ${x}`, + ); + } +} + +export class ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED extends NodeError { + constructor() { + super( + "ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED", + "Custom engines not supported by this OpenSSL", + ); + } +} + +export class ERR_CRYPTO_ECDH_INVALID_FORMAT extends NodeTypeError { + constructor(x: string) { + super( + "ERR_CRYPTO_ECDH_INVALID_FORMAT", + `Invalid ECDH format: ${x}`, + ); + } +} + +export class ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY extends NodeError { + constructor() { + super( + "ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY", + "Public key is not valid for specified curve", + ); + } +} + +export class ERR_CRYPTO_ENGINE_UNKNOWN extends NodeError { + constructor(x: string) { + super( + "ERR_CRYPTO_ENGINE_UNKNOWN", + `Engine "${x}" was not found`, + ); + } +} + +export class ERR_CRYPTO_FIPS_FORCED extends NodeError { + constructor() { + super( + "ERR_CRYPTO_FIPS_FORCED", + "Cannot set FIPS mode, it was forced with --force-fips at startup.", + ); + } +} + +export class ERR_CRYPTO_FIPS_UNAVAILABLE extends NodeError { + constructor() { + super( + "ERR_CRYPTO_FIPS_UNAVAILABLE", + "Cannot set FIPS mode in a non-FIPS build.", + ); + } +} + +export class ERR_CRYPTO_HASH_FINALIZED extends NodeError { + constructor() { + super( + "ERR_CRYPTO_HASH_FINALIZED", + "Digest already called", + ); + } +} + +export class ERR_CRYPTO_HASH_UPDATE_FAILED extends NodeError { + constructor() { + super( + "ERR_CRYPTO_HASH_UPDATE_FAILED", + "Hash update failed", + ); + } +} + +export class ERR_CRYPTO_INCOMPATIBLE_KEY extends NodeError { + constructor(x: string, y: string) { + super( + "ERR_CRYPTO_INCOMPATIBLE_KEY", + `Incompatible ${x}: ${y}`, + ); + } +} + +export class ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS extends NodeError { + constructor(x: string, y: string) { + super( + "ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS", + `The selected key encoding ${x} ${y}.`, + ); + } +} + +export class ERR_CRYPTO_INVALID_DIGEST extends NodeTypeError { + constructor(x: string) { + super( + "ERR_CRYPTO_INVALID_DIGEST", + `Invalid digest: ${x}`, + ); + } +} + +export class ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE extends NodeTypeError { + constructor(x: string, y: string) { + super( + "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", + `Invalid key object type ${x}, expected ${y}.`, + ); + } +} + +export class ERR_CRYPTO_INVALID_STATE extends NodeError { + constructor(x: string) { + super( + "ERR_CRYPTO_INVALID_STATE", + `Invalid state for operation ${x}`, + ); + } +} + +export class ERR_CRYPTO_PBKDF2_ERROR extends NodeError { + constructor() { + super( + "ERR_CRYPTO_PBKDF2_ERROR", + "PBKDF2 error", + ); + } +} + +export class ERR_CRYPTO_SCRYPT_INVALID_PARAMETER extends NodeError { + constructor() { + super( + "ERR_CRYPTO_SCRYPT_INVALID_PARAMETER", + "Invalid scrypt parameter", + ); + } +} + +export class ERR_CRYPTO_SCRYPT_NOT_SUPPORTED extends NodeError { + constructor() { + super( + "ERR_CRYPTO_SCRYPT_NOT_SUPPORTED", + "Scrypt algorithm not supported", + ); + } +} + +export class ERR_CRYPTO_SIGN_KEY_REQUIRED extends NodeError { + constructor() { + super( + "ERR_CRYPTO_SIGN_KEY_REQUIRED", + "No key provided to sign", + ); + } +} + +export class ERR_DIR_CLOSED extends NodeError { + constructor() { + super( + "ERR_DIR_CLOSED", + "Directory handle was closed", + ); + } +} + +export class ERR_DIR_CONCURRENT_OPERATION extends NodeError { + constructor() { + super( + "ERR_DIR_CONCURRENT_OPERATION", + "Cannot do synchronous work on directory handle with concurrent asynchronous operations", + ); + } +} + +export class ERR_DNS_SET_SERVERS_FAILED extends NodeError { + constructor(x: string, y: string) { + super( + "ERR_DNS_SET_SERVERS_FAILED", + `c-ares failed to set servers: "${x}" [${y}]`, + ); + } +} + +export class ERR_DOMAIN_CALLBACK_NOT_AVAILABLE extends NodeError { + constructor() { + super( + "ERR_DOMAIN_CALLBACK_NOT_AVAILABLE", + "A callback was registered through " + + "process.setUncaughtExceptionCaptureCallback(), which is mutually " + + "exclusive with using the `domain` module", + ); + } +} + +export class ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE + extends NodeError { + constructor() { + super( + "ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE", + "The `domain` module is in use, which is mutually exclusive with calling " + + "process.setUncaughtExceptionCaptureCallback()", + ); + } +} + +export class ERR_ENCODING_INVALID_ENCODED_DATA extends NodeErrorAbstraction + implements TypeError { + errno: number; + constructor(encoding: string, ret: number) { + super( + TypeError.prototype.name, + "ERR_ENCODING_INVALID_ENCODED_DATA", + `The encoded data was not valid for encoding ${encoding}`, + ); + Object.setPrototypeOf(this, TypeError.prototype); + + this.errno = ret; + } +} + // In Node these values are coming from libuv: // Ref: https://github.com/libuv/libuv/blob/v1.x/include/uv/errno.h // Ref: https://github.com/nodejs/node/blob/524123fbf064ff64bb6fcd83485cfc27db932f68/lib/internal/errors.js#L383 @@ -384,6 +719,734 @@ export const errorMap = new Map( ? linux : unreachable(), ); +export class ERR_ENCODING_NOT_SUPPORTED extends NodeRangeError { + constructor(x: string) { + super( + "ERR_ENCODING_NOT_SUPPORTED", + `The "${x}" encoding is not supported`, + ); + } +} +export class ERR_EVAL_ESM_CANNOT_PRINT extends NodeError { + constructor() { + super( + "ERR_EVAL_ESM_CANNOT_PRINT", + `--print cannot be used with ESM input`, + ); + } +} +export class ERR_EVENT_RECURSION extends NodeError { + constructor(x: string) { + super( + "ERR_EVENT_RECURSION", + `The event "${x}" is already being dispatched`, + ); + } +} +export class ERR_FEATURE_UNAVAILABLE_ON_PLATFORM extends NodeTypeError { + constructor(x: string) { + super( + "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM", + `The feature ${x} is unavailable on the current platform, which is being used to run Node.js`, + ); + } +} +export class ERR_FS_FILE_TOO_LARGE extends NodeRangeError { + constructor(x: string) { + super( + "ERR_FS_FILE_TOO_LARGE", + `File size (${x}) is greater than 2 GB`, + ); + } +} +export class ERR_FS_INVALID_SYMLINK_TYPE extends NodeError { + constructor(x: string) { + super( + "ERR_FS_INVALID_SYMLINK_TYPE", + `Symlink type must be one of "dir", "file", or "junction". Received "${x}"`, + ); + } +} +export class ERR_HTTP2_ALTSVC_INVALID_ORIGIN extends NodeTypeError { + constructor() { + super( + "ERR_HTTP2_ALTSVC_INVALID_ORIGIN", + `HTTP/2 ALTSVC frames require a valid origin`, + ); + } +} +export class ERR_HTTP2_ALTSVC_LENGTH extends NodeTypeError { + constructor() { + super( + "ERR_HTTP2_ALTSVC_LENGTH", + `HTTP/2 ALTSVC frames are limited to 16382 bytes`, + ); + } +} +export class ERR_HTTP2_CONNECT_AUTHORITY extends NodeError { + constructor() { + super( + "ERR_HTTP2_CONNECT_AUTHORITY", + `:authority header is required for CONNECT requests`, + ); + } +} +export class ERR_HTTP2_CONNECT_PATH extends NodeError { + constructor() { + super( + "ERR_HTTP2_CONNECT_PATH", + `The :path header is forbidden for CONNECT requests`, + ); + } +} +export class ERR_HTTP2_CONNECT_SCHEME extends NodeError { + constructor() { + super( + "ERR_HTTP2_CONNECT_SCHEME", + `The :scheme header is forbidden for CONNECT requests`, + ); + } +} +export class ERR_HTTP2_GOAWAY_SESSION extends NodeError { + constructor() { + super( + "ERR_HTTP2_GOAWAY_SESSION", + `New streams cannot be created after receiving a GOAWAY`, + ); + } +} +export class ERR_HTTP2_HEADERS_AFTER_RESPOND extends NodeError { + constructor() { + super( + "ERR_HTTP2_HEADERS_AFTER_RESPOND", + `Cannot specify additional headers after response initiated`, + ); + } +} +export class ERR_HTTP2_HEADERS_SENT extends NodeError { + constructor() { + super( + "ERR_HTTP2_HEADERS_SENT", + `Response has already been initiated.`, + ); + } +} +export class ERR_HTTP2_HEADER_SINGLE_VALUE extends NodeTypeError { + constructor(x: string) { + super( + "ERR_HTTP2_HEADER_SINGLE_VALUE", + `Header field "${x}" must only have a single value`, + ); + } +} +export class ERR_HTTP2_INFO_STATUS_NOT_ALLOWED extends NodeRangeError { + constructor() { + super( + "ERR_HTTP2_INFO_STATUS_NOT_ALLOWED", + `Informational status codes cannot be used`, + ); + } +} +export class ERR_HTTP2_INVALID_CONNECTION_HEADERS extends NodeTypeError { + constructor(x: string) { + super( + "ERR_HTTP2_INVALID_CONNECTION_HEADERS", + `HTTP/1 Connection specific headers are forbidden: "${x}"`, + ); + } +} +export class ERR_HTTP2_INVALID_HEADER_VALUE extends NodeTypeError { + constructor(x: string, y: string) { + super( + "ERR_HTTP2_INVALID_HEADER_VALUE", + `Invalid value "${x}" for header "${y}"`, + ); + } +} +export class ERR_HTTP2_INVALID_INFO_STATUS extends NodeRangeError { + constructor(x: string) { + super( + "ERR_HTTP2_INVALID_INFO_STATUS", + `Invalid informational status code: ${x}`, + ); + } +} +export class ERR_HTTP2_INVALID_ORIGIN extends NodeTypeError { + constructor() { + super( + "ERR_HTTP2_INVALID_ORIGIN", + `HTTP/2 ORIGIN frames require a valid origin`, + ); + } +} +export class ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH extends NodeRangeError { + constructor() { + super( + "ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH", + `Packed settings length must be a multiple of six`, + ); + } +} +export class ERR_HTTP2_INVALID_PSEUDOHEADER extends NodeTypeError { + constructor(x: string) { + super( + "ERR_HTTP2_INVALID_PSEUDOHEADER", + `"${x}" is an invalid pseudoheader or is used incorrectly`, + ); + } +} +export class ERR_HTTP2_INVALID_SESSION extends NodeError { + constructor() { + super( + "ERR_HTTP2_INVALID_SESSION", + `The session has been destroyed`, + ); + } +} +export class ERR_HTTP2_INVALID_STREAM extends NodeError { + constructor() { + super( + "ERR_HTTP2_INVALID_STREAM", + `The stream has been destroyed`, + ); + } +} +export class ERR_HTTP2_MAX_PENDING_SETTINGS_ACK extends NodeError { + constructor() { + super( + "ERR_HTTP2_MAX_PENDING_SETTINGS_ACK", + `Maximum number of pending settings acknowledgements`, + ); + } +} +export class ERR_HTTP2_NESTED_PUSH extends NodeError { + constructor() { + super( + "ERR_HTTP2_NESTED_PUSH", + `A push stream cannot initiate another push stream.`, + ); + } +} +export class ERR_HTTP2_NO_SOCKET_MANIPULATION extends NodeError { + constructor() { + super( + "ERR_HTTP2_NO_SOCKET_MANIPULATION", + `HTTP/2 sockets should not be directly manipulated (e.g. read and written)`, + ); + } +} +export class ERR_HTTP2_ORIGIN_LENGTH extends NodeTypeError { + constructor() { + super( + "ERR_HTTP2_ORIGIN_LENGTH", + `HTTP/2 ORIGIN frames are limited to 16382 bytes`, + ); + } +} +export class ERR_HTTP2_OUT_OF_STREAMS extends NodeError { + constructor() { + super( + "ERR_HTTP2_OUT_OF_STREAMS", + `No stream ID is available because maximum stream ID has been reached`, + ); + } +} +export class ERR_HTTP2_PAYLOAD_FORBIDDEN extends NodeError { + constructor(x: string) { + super( + "ERR_HTTP2_PAYLOAD_FORBIDDEN", + `Responses with ${x} status must not have a payload`, + ); + } +} +export class ERR_HTTP2_PING_CANCEL extends NodeError { + constructor() { + super( + "ERR_HTTP2_PING_CANCEL", + `HTTP2 ping cancelled`, + ); + } +} +export class ERR_HTTP2_PING_LENGTH extends NodeRangeError { + constructor() { + super( + "ERR_HTTP2_PING_LENGTH", + `HTTP2 ping payload must be 8 bytes`, + ); + } +} +export class ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED extends NodeTypeError { + constructor() { + super( + "ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED", + `Cannot set HTTP/2 pseudo-headers`, + ); + } +} +export class ERR_HTTP2_PUSH_DISABLED extends NodeError { + constructor() { + super( + "ERR_HTTP2_PUSH_DISABLED", + `HTTP/2 client has disabled push streams`, + ); + } +} +export class ERR_HTTP2_SEND_FILE extends NodeError { + constructor() { + super( + "ERR_HTTP2_SEND_FILE", + `Directories cannot be sent`, + ); + } +} +export class ERR_HTTP2_SEND_FILE_NOSEEK extends NodeError { + constructor() { + super( + "ERR_HTTP2_SEND_FILE_NOSEEK", + `Offset or length can only be specified for regular files`, + ); + } +} +export class ERR_HTTP2_SESSION_ERROR extends NodeError { + constructor(x: string) { + super( + "ERR_HTTP2_SESSION_ERROR", + `Session closed with error code ${x}`, + ); + } +} +export class ERR_HTTP2_SETTINGS_CANCEL extends NodeError { + constructor() { + super( + "ERR_HTTP2_SETTINGS_CANCEL", + `HTTP2 session settings canceled`, + ); + } +} +export class ERR_HTTP2_SOCKET_BOUND extends NodeError { + constructor() { + super( + "ERR_HTTP2_SOCKET_BOUND", + `The socket is already bound to an Http2Session`, + ); + } +} +export class ERR_HTTP2_SOCKET_UNBOUND extends NodeError { + constructor() { + super( + "ERR_HTTP2_SOCKET_UNBOUND", + `The socket has been disconnected from the Http2Session`, + ); + } +} +export class ERR_HTTP2_STATUS_101 extends NodeError { + constructor() { + super( + "ERR_HTTP2_STATUS_101", + `HTTP status code 101 (Switching Protocols) is forbidden in HTTP/2`, + ); + } +} +export class ERR_HTTP2_STATUS_INVALID extends NodeRangeError { + constructor(x: string) { + super( + "ERR_HTTP2_STATUS_INVALID", + `Invalid status code: ${x}`, + ); + } +} +export class ERR_HTTP2_STREAM_ERROR extends NodeError { + constructor(x: string) { + super( + "ERR_HTTP2_STREAM_ERROR", + `Stream closed with error code ${x}`, + ); + } +} +export class ERR_HTTP2_STREAM_SELF_DEPENDENCY extends NodeError { + constructor() { + super( + "ERR_HTTP2_STREAM_SELF_DEPENDENCY", + `A stream cannot depend on itself`, + ); + } +} +export class ERR_HTTP2_TRAILERS_ALREADY_SENT extends NodeError { + constructor() { + super( + "ERR_HTTP2_TRAILERS_ALREADY_SENT", + `Trailing headers have already been sent`, + ); + } +} +export class ERR_HTTP2_TRAILERS_NOT_READY extends NodeError { + constructor() { + super( + "ERR_HTTP2_TRAILERS_NOT_READY", + `Trailing headers cannot be sent until after the wantTrailers event is emitted`, + ); + } +} +export class ERR_HTTP2_UNSUPPORTED_PROTOCOL extends NodeError { + constructor(x: string) { + super( + "ERR_HTTP2_UNSUPPORTED_PROTOCOL", + `protocol "${x}" is unsupported.`, + ); + } +} +export class ERR_HTTP_HEADERS_SENT extends NodeError { + constructor(x: string) { + super( + "ERR_HTTP_HEADERS_SENT", + `Cannot ${x} headers after they are sent to the client`, + ); + } +} +export class ERR_HTTP_INVALID_HEADER_VALUE extends NodeTypeError { + constructor(x: string, y: string) { + super( + "ERR_HTTP_INVALID_HEADER_VALUE", + `Invalid value "${x}" for header "${y}"`, + ); + } +} +export class ERR_HTTP_INVALID_STATUS_CODE extends NodeRangeError { + constructor(x: string) { + super( + "ERR_HTTP_INVALID_STATUS_CODE", + `Invalid status code: ${x}`, + ); + } +} +export class ERR_HTTP_SOCKET_ENCODING extends NodeError { + constructor() { + super( + "ERR_HTTP_SOCKET_ENCODING", + `Changing the socket encoding is not allowed per RFC7230 Section 3.`, + ); + } +} +export class ERR_HTTP_TRAILER_INVALID extends NodeError { + constructor() { + super( + "ERR_HTTP_TRAILER_INVALID", + `Trailers are invalid with this transfer encoding`, + ); + } +} +export class ERR_INCOMPATIBLE_OPTION_PAIR extends NodeTypeError { + constructor(x: string, y: string) { + super( + "ERR_INCOMPATIBLE_OPTION_PAIR", + `Option "${x}" cannot be used in combination with option "${y}"`, + ); + } +} +export class ERR_INPUT_TYPE_NOT_ALLOWED extends NodeError { + constructor() { + super( + "ERR_INPUT_TYPE_NOT_ALLOWED", + `--input-type can only be used with string input via --eval, --print, or STDIN`, + ); + } +} +export class ERR_INSPECTOR_ALREADY_ACTIVATED extends NodeError { + constructor() { + super( + "ERR_INSPECTOR_ALREADY_ACTIVATED", + `Inspector is already activated. Close it with inspector.close() before activating it again.`, + ); + } +} +export class ERR_INSPECTOR_ALREADY_CONNECTED extends NodeError { + constructor(x: string) { + super( + "ERR_INSPECTOR_ALREADY_CONNECTED", + `${x} is already connected`, + ); + } +} +export class ERR_INSPECTOR_CLOSED extends NodeError { + constructor() { + super( + "ERR_INSPECTOR_CLOSED", + `Session was closed`, + ); + } +} +export class ERR_INSPECTOR_COMMAND extends NodeError { + constructor(x: number, y: string) { + super( + "ERR_INSPECTOR_COMMAND", + `Inspector error ${x}: ${y}`, + ); + } +} +export class ERR_INSPECTOR_NOT_ACTIVE extends NodeError { + constructor() { + super( + "ERR_INSPECTOR_NOT_ACTIVE", + `Inspector is not active`, + ); + } +} +export class ERR_INSPECTOR_NOT_AVAILABLE extends NodeError { + constructor() { + super( + "ERR_INSPECTOR_NOT_AVAILABLE", + `Inspector is not available`, + ); + } +} +export class ERR_INSPECTOR_NOT_CONNECTED extends NodeError { + constructor() { + super( + "ERR_INSPECTOR_NOT_CONNECTED", + `Session is not connected`, + ); + } +} +export class ERR_INSPECTOR_NOT_WORKER extends NodeError { + constructor() { + super( + "ERR_INSPECTOR_NOT_WORKER", + `Current thread is not a worker`, + ); + } +} +export class ERR_INVALID_ASYNC_ID extends NodeRangeError { + constructor(x: string, y: string) { + super( + "ERR_INVALID_ASYNC_ID", + `Invalid ${x} value: ${y}`, + ); + } +} +export class ERR_INVALID_BUFFER_SIZE extends NodeRangeError { + constructor(x: string) { + super( + "ERR_INVALID_BUFFER_SIZE", + `Buffer size must be a multiple of ${x}`, + ); + } +} +export class ERR_INVALID_CALLBACK extends NodeTypeError { + constructor(object: { [key: string]: unknown }) { + super( + "ERR_INVALID_CALLBACK", + `Callback must be a function. Received ${JSON.stringify(object)}`, + ); + } +} +export class ERR_INVALID_CURSOR_POS extends NodeTypeError { + constructor() { + super( + "ERR_INVALID_CURSOR_POS", + `Cannot set cursor row without setting its column`, + ); + } +} +export class ERR_INVALID_FD extends NodeRangeError { + constructor(x: string) { + super( + "ERR_INVALID_FD", + `"fd" must be a positive integer: ${x}`, + ); + } +} +export class ERR_INVALID_FD_TYPE extends NodeTypeError { + constructor(x: string) { + super( + "ERR_INVALID_FD_TYPE", + `Unsupported fd type: ${x}`, + ); + } +} +export class ERR_INVALID_FILE_URL_HOST extends NodeTypeError { + constructor(x: string) { + super( + "ERR_INVALID_FILE_URL_HOST", + `File URL host must be "localhost" or empty on ${x}`, + ); + } +} +export class ERR_INVALID_FILE_URL_PATH extends NodeTypeError { + constructor(x: string) { + super( + "ERR_INVALID_FILE_URL_PATH", + `File URL path ${x}`, + ); + } +} +export class ERR_INVALID_HANDLE_TYPE extends NodeTypeError { + constructor() { + super( + "ERR_INVALID_HANDLE_TYPE", + `This handle type cannot be sent`, + ); + } +} +export class ERR_INVALID_HTTP_TOKEN extends NodeTypeError { + constructor(x: string, y: string) { + super( + "ERR_INVALID_HTTP_TOKEN", + `${x} must be a valid HTTP token ["${y}"]`, + ); + } +} +export class ERR_INVALID_IP_ADDRESS extends NodeTypeError { + constructor(x: string) { + super( + "ERR_INVALID_IP_ADDRESS", + `Invalid IP address: ${x}`, + ); + } +} +export class ERR_INVALID_OPT_VALUE_ENCODING extends NodeTypeError { + constructor(x: string) { + super( + "ERR_INVALID_OPT_VALUE_ENCODING", + `The value "${x}" is invalid for option "encoding"`, + ); + } +} +export class ERR_INVALID_PERFORMANCE_MARK extends NodeError { + constructor(x: string) { + super( + "ERR_INVALID_PERFORMANCE_MARK", + `The "${x}" performance mark has not been set`, + ); + } +} +export class ERR_INVALID_PROTOCOL extends NodeTypeError { + constructor(x: string, y: string) { + super( + "ERR_INVALID_PROTOCOL", + `Protocol "${x}" not supported. Expected "${y}"`, + ); + } +} +export class ERR_INVALID_REPL_EVAL_CONFIG extends NodeTypeError { + constructor() { + super( + "ERR_INVALID_REPL_EVAL_CONFIG", + `Cannot specify both "breakEvalOnSigint" and "eval" for REPL`, + ); + } +} +export class ERR_INVALID_REPL_INPUT extends NodeTypeError { + constructor(x: string) { + super( + "ERR_INVALID_REPL_INPUT", + `${x}`, + ); + } +} +export class ERR_INVALID_SYNC_FORK_INPUT extends NodeTypeError { + constructor(x: string) { + super( + "ERR_INVALID_SYNC_FORK_INPUT", + `Asynchronous forks do not support Buffer, TypedArray, DataView or string input: ${x}`, + ); + } +} +export class ERR_INVALID_THIS extends NodeTypeError { + constructor(x: string) { + super( + "ERR_INVALID_THIS", + `Value of "this" must be of type ${x}`, + ); + } +} +export class ERR_INVALID_TUPLE extends NodeTypeError { + constructor(x: string, y: string) { + super( + "ERR_INVALID_TUPLE", + `${x} must be an iterable ${y} tuple`, + ); + } +} +export class ERR_INVALID_URI extends NodeURIError { + constructor() { + super( + "ERR_INVALID_URI", + `URI malformed`, + ); + } +} +export class ERR_IPC_CHANNEL_CLOSED extends NodeError { + constructor() { + super( + "ERR_IPC_CHANNEL_CLOSED", + `Channel closed`, + ); + } +} +export class ERR_IPC_DISCONNECTED extends NodeError { + constructor() { + super( + "ERR_IPC_DISCONNECTED", + `IPC channel is already disconnected`, + ); + } +} +export class ERR_IPC_ONE_PIPE extends NodeError { + constructor() { + super( + "ERR_IPC_ONE_PIPE", + `Child process can have only one IPC pipe`, + ); + } +} +export class ERR_IPC_SYNC_FORK extends NodeError { + constructor() { + super( + "ERR_IPC_SYNC_FORK", + `IPC cannot be used with synchronous forks`, + ); + } +} +export class ERR_MANIFEST_DEPENDENCY_MISSING extends NodeError { + constructor(x: string, y: string) { + super( + "ERR_MANIFEST_DEPENDENCY_MISSING", + `Manifest resource ${x} does not list ${y} as a dependency specifier`, + ); + } +} +export class ERR_MANIFEST_INTEGRITY_MISMATCH extends NodeSyntaxError { + constructor(x: string) { + super( + "ERR_MANIFEST_INTEGRITY_MISMATCH", + `Manifest resource ${x} has multiple entries but integrity lists do not match`, + ); + } +} +export class ERR_MANIFEST_INVALID_RESOURCE_FIELD extends NodeTypeError { + constructor(x: string, y: string) { + super( + "ERR_MANIFEST_INVALID_RESOURCE_FIELD", + `Manifest resource ${x} has invalid property value for ${y}`, + ); + } +} +export class ERR_MANIFEST_TDZ extends NodeError { + constructor() { + super( + "ERR_MANIFEST_TDZ", + `Manifest initialization has not yet run`, + ); + } +} +export class ERR_MANIFEST_UNKNOWN_ONERROR extends NodeSyntaxError { + constructor(x: string) { + super( + "ERR_MANIFEST_UNKNOWN_ONERROR", + `Manifest specified unknown error behavior "${x}".`, + ); + } +} export class ERR_METHOD_NOT_IMPLEMENTED extends NodeError { constructor(x: string) { super( @@ -392,6 +1455,37 @@ export class ERR_METHOD_NOT_IMPLEMENTED extends NodeError { ); } } +export class ERR_MISSING_ARGS extends NodeTypeError { + constructor(...args: string[]) { + args = args.map((a) => `"${a}"`); + + let msg = "The "; + switch (args.length) { + case 1: + msg += `${args[0]} argument`; + break; + case 2: + msg += `${args[0]} and ${args[1]} arguments`; + break; + default: + msg += args.slice(0, args.length - 1).join(", "); + msg += `, and ${args[args.length - 1]} arguments`; + break; + } + super( + "ERR_MISSING_ARGS", + `${msg} must be specified`, + ); + } +} +export class ERR_MISSING_OPTION extends NodeTypeError { + constructor(x: string) { + super( + "ERR_MISSING_OPTION", + `${x} is required`, + ); + } +} export class ERR_MULTIPLE_CALLBACK extends NodeError { constructor() { super( @@ -400,6 +1494,255 @@ export class ERR_MULTIPLE_CALLBACK extends NodeError { ); } } +export class ERR_NAPI_CONS_FUNCTION extends NodeTypeError { + constructor() { + super( + "ERR_NAPI_CONS_FUNCTION", + `Constructor must be a function`, + ); + } +} +export class ERR_NAPI_INVALID_DATAVIEW_ARGS extends NodeRangeError { + constructor() { + super( + "ERR_NAPI_INVALID_DATAVIEW_ARGS", + `byte_offset + byte_length should be less than or equal to the size in bytes of the array passed in`, + ); + } +} +export class ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT extends NodeRangeError { + constructor(x: string, y: string) { + super( + "ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT", + `start offset of ${x} should be a multiple of ${y}`, + ); + } +} +export class ERR_NAPI_INVALID_TYPEDARRAY_LENGTH extends NodeRangeError { + constructor() { + super( + "ERR_NAPI_INVALID_TYPEDARRAY_LENGTH", + `Invalid typed array length`, + ); + } +} +export class ERR_NO_CRYPTO extends NodeError { + constructor() { + super( + "ERR_NO_CRYPTO", + `Node.js is not compiled with OpenSSL crypto support`, + ); + } +} +export class ERR_NO_ICU extends NodeTypeError { + constructor(x: string) { + super( + "ERR_NO_ICU", + `${x} is not supported on Node.js compiled without ICU`, + ); + } +} +export class ERR_QUICCLIENTSESSION_FAILED extends NodeError { + constructor(x: string) { + super( + "ERR_QUICCLIENTSESSION_FAILED", + `Failed to create a new QuicClientSession: ${x}`, + ); + } +} +export class ERR_QUICCLIENTSESSION_FAILED_SETSOCKET extends NodeError { + constructor() { + super( + "ERR_QUICCLIENTSESSION_FAILED_SETSOCKET", + `Failed to set the QuicSocket`, + ); + } +} +export class ERR_QUICSESSION_DESTROYED extends NodeError { + constructor(x: string) { + super( + "ERR_QUICSESSION_DESTROYED", + `Cannot call ${x} after a QuicSession has been destroyed`, + ); + } +} +export class ERR_QUICSESSION_INVALID_DCID extends NodeError { + constructor(x: string) { + super( + "ERR_QUICSESSION_INVALID_DCID", + `Invalid DCID value: ${x}`, + ); + } +} +export class ERR_QUICSESSION_UPDATEKEY extends NodeError { + constructor() { + super( + "ERR_QUICSESSION_UPDATEKEY", + `Unable to update QuicSession keys`, + ); + } +} +export class ERR_QUICSOCKET_DESTROYED extends NodeError { + constructor(x: string) { + super( + "ERR_QUICSOCKET_DESTROYED", + `Cannot call ${x} after a QuicSocket has been destroyed`, + ); + } +} +export class ERR_QUICSOCKET_INVALID_STATELESS_RESET_SECRET_LENGTH + extends NodeError { + constructor() { + super( + "ERR_QUICSOCKET_INVALID_STATELESS_RESET_SECRET_LENGTH", + `The stateResetToken must be exactly 16-bytes in length`, + ); + } +} +export class ERR_QUICSOCKET_LISTENING extends NodeError { + constructor() { + super( + "ERR_QUICSOCKET_LISTENING", + `This QuicSocket is already listening`, + ); + } +} +export class ERR_QUICSOCKET_UNBOUND extends NodeError { + constructor(x: string) { + super( + "ERR_QUICSOCKET_UNBOUND", + `Cannot call ${x} before a QuicSocket has been bound`, + ); + } +} +export class ERR_QUICSTREAM_DESTROYED extends NodeError { + constructor(x: string) { + super( + "ERR_QUICSTREAM_DESTROYED", + `Cannot call ${x} after a QuicStream has been destroyed`, + ); + } +} +export class ERR_QUICSTREAM_INVALID_PUSH extends NodeError { + constructor() { + super( + "ERR_QUICSTREAM_INVALID_PUSH", + `Push streams are only supported on client-initiated, bidirectional streams`, + ); + } +} +export class ERR_QUICSTREAM_OPEN_FAILED extends NodeError { + constructor() { + super( + "ERR_QUICSTREAM_OPEN_FAILED", + `Opening a new QuicStream failed`, + ); + } +} +export class ERR_QUICSTREAM_UNSUPPORTED_PUSH extends NodeError { + constructor() { + super( + "ERR_QUICSTREAM_UNSUPPORTED_PUSH", + `Push streams are not supported on this QuicSession`, + ); + } +} +export class ERR_QUIC_TLS13_REQUIRED extends NodeError { + constructor() { + super( + "ERR_QUIC_TLS13_REQUIRED", + `QUIC requires TLS version 1.3`, + ); + } +} +export class ERR_SCRIPT_EXECUTION_INTERRUPTED extends NodeError { + constructor() { + super( + "ERR_SCRIPT_EXECUTION_INTERRUPTED", + "Script execution was interrupted by `SIGINT`", + ); + } +} +export class ERR_SERVER_ALREADY_LISTEN extends NodeError { + constructor() { + super( + "ERR_SERVER_ALREADY_LISTEN", + `Listen method has been called more than once without closing.`, + ); + } +} +export class ERR_SERVER_NOT_RUNNING extends NodeError { + constructor() { + super( + "ERR_SERVER_NOT_RUNNING", + `Server is not running.`, + ); + } +} +export class ERR_SOCKET_ALREADY_BOUND extends NodeError { + constructor() { + super( + "ERR_SOCKET_ALREADY_BOUND", + `Socket is already bound`, + ); + } +} +export class ERR_SOCKET_BAD_BUFFER_SIZE extends NodeTypeError { + constructor() { + super( + "ERR_SOCKET_BAD_BUFFER_SIZE", + `Buffer size must be a positive integer`, + ); + } +} +export class ERR_SOCKET_BAD_TYPE extends NodeTypeError { + constructor() { + super( + "ERR_SOCKET_BAD_TYPE", + `Bad socket type specified. Valid types are: udp4, udp6`, + ); + } +} +export class ERR_SOCKET_CLOSED extends NodeError { + constructor() { + super( + "ERR_SOCKET_CLOSED", + `Socket is closed`, + ); + } +} +export class ERR_SOCKET_DGRAM_IS_CONNECTED extends NodeError { + constructor() { + super( + "ERR_SOCKET_DGRAM_IS_CONNECTED", + `Already connected`, + ); + } +} +export class ERR_SOCKET_DGRAM_NOT_CONNECTED extends NodeError { + constructor() { + super( + "ERR_SOCKET_DGRAM_NOT_CONNECTED", + `Not connected`, + ); + } +} +export class ERR_SOCKET_DGRAM_NOT_RUNNING extends NodeError { + constructor() { + super( + "ERR_SOCKET_DGRAM_NOT_RUNNING", + `Not running`, + ); + } +} +export class ERR_SRI_PARSE extends NodeSyntaxError { + constructor(name: string, char: string, position: number) { + super( + "ERR_SRI_PARSE", + `Subresource Integrity string ${name} had an unexpected ${char} at position ${position}`, + ); + } +} export class ERR_STREAM_ALREADY_FINISHED extends NodeError { constructor(x: string) { super( @@ -456,6 +1799,14 @@ export class ERR_STREAM_UNSHIFT_AFTER_END_EVENT extends NodeError { ); } } +export class ERR_STREAM_WRAP extends NodeError { + constructor() { + super( + "ERR_STREAM_WRAP", + `Stream has StringDecoder set or is in objectMode`, + ); + } +} export class ERR_STREAM_WRITE_AFTER_END extends NodeError { constructor() { super( @@ -464,6 +1815,150 @@ export class ERR_STREAM_WRITE_AFTER_END extends NodeError { ); } } +export class ERR_SYNTHETIC extends NodeError { + constructor() { + super( + "ERR_SYNTHETIC", + `JavaScript Callstack`, + ); + } +} +export class ERR_TLS_DH_PARAM_SIZE extends NodeError { + constructor(x: string) { + super( + "ERR_TLS_DH_PARAM_SIZE", + `DH parameter size ${x} is less than 2048`, + ); + } +} +export class ERR_TLS_HANDSHAKE_TIMEOUT extends NodeError { + constructor() { + super( + "ERR_TLS_HANDSHAKE_TIMEOUT", + `TLS handshake timeout`, + ); + } +} +export class ERR_TLS_INVALID_CONTEXT extends NodeTypeError { + constructor(x: string) { + super( + "ERR_TLS_INVALID_CONTEXT", + `${x} must be a SecureContext`, + ); + } +} +export class ERR_TLS_INVALID_STATE extends NodeError { + constructor() { + super( + "ERR_TLS_INVALID_STATE", + `TLS socket connection must be securely established`, + ); + } +} +export class ERR_TLS_INVALID_PROTOCOL_VERSION extends NodeTypeError { + constructor(protocol: string, x: string) { + super( + "ERR_TLS_INVALID_PROTOCOL_VERSION", + `${protocol} is not a valid ${x} TLS protocol version`, + ); + } +} +export class ERR_TLS_PROTOCOL_VERSION_CONFLICT extends NodeTypeError { + constructor(prevProtocol: string, protocol: string) { + super( + "ERR_TLS_PROTOCOL_VERSION_CONFLICT", + `TLS protocol version ${prevProtocol} conflicts with secureProtocol ${protocol}`, + ); + } +} +export class ERR_TLS_RENEGOTIATION_DISABLED extends NodeError { + constructor() { + super( + "ERR_TLS_RENEGOTIATION_DISABLED", + `TLS session renegotiation disabled for this socket`, + ); + } +} +export class ERR_TLS_REQUIRED_SERVER_NAME extends NodeError { + constructor() { + super( + "ERR_TLS_REQUIRED_SERVER_NAME", + `"servername" is required parameter for Server.addContext`, + ); + } +} +export class ERR_TLS_SESSION_ATTACK extends NodeError { + constructor() { + super( + "ERR_TLS_SESSION_ATTACK", + `TLS session renegotiation attack detected`, + ); + } +} +export class ERR_TLS_SNI_FROM_SERVER extends NodeError { + constructor() { + super( + "ERR_TLS_SNI_FROM_SERVER", + `Cannot issue SNI from a TLS server-side socket`, + ); + } +} +export class ERR_TRACE_EVENTS_CATEGORY_REQUIRED extends NodeTypeError { + constructor() { + super( + "ERR_TRACE_EVENTS_CATEGORY_REQUIRED", + `At least one category is required`, + ); + } +} +export class ERR_TRACE_EVENTS_UNAVAILABLE extends NodeError { + constructor() { + super( + "ERR_TRACE_EVENTS_UNAVAILABLE", + `Trace events are unavailable`, + ); + } +} +export class ERR_UNAVAILABLE_DURING_EXIT extends NodeError { + constructor() { + super( + "ERR_UNAVAILABLE_DURING_EXIT", + `Cannot call function in process exit handler`, + ); + } +} +export class ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET extends NodeError { + constructor() { + super( + "ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET", + "`process.setupUncaughtExceptionCapture()` was called while a capture callback was already active", + ); + } +} +export class ERR_UNESCAPED_CHARACTERS extends NodeTypeError { + constructor(x: string) { + super( + "ERR_UNESCAPED_CHARACTERS", + `${x} contains unescaped characters`, + ); + } +} +export class ERR_UNKNOWN_BUILTIN_MODULE extends NodeError { + constructor(x: string) { + super( + "ERR_UNKNOWN_BUILTIN_MODULE", + `No such built-in module: ${x}`, + ); + } +} +export class ERR_UNKNOWN_CREDENTIAL extends NodeError { + constructor(x: string, y: string) { + super( + "ERR_UNKNOWN_CREDENTIAL", + `${x} identifier does not exist: ${y}`, + ); + } +} export class ERR_UNKNOWN_ENCODING extends NodeTypeError { constructor(x: string) { super( @@ -472,6 +1967,247 @@ export class ERR_UNKNOWN_ENCODING extends NodeTypeError { ); } } +export class ERR_UNKNOWN_FILE_EXTENSION extends NodeTypeError { + constructor(x: string, y: string) { + super( + "ERR_UNKNOWN_FILE_EXTENSION", + `Unknown file extension "${x}" for ${y}`, + ); + } +} +export class ERR_UNKNOWN_MODULE_FORMAT extends NodeRangeError { + constructor(x: string) { + super( + "ERR_UNKNOWN_MODULE_FORMAT", + `Unknown module format: ${x}`, + ); + } +} +export class ERR_UNKNOWN_SIGNAL extends NodeTypeError { + constructor(x: string) { + super( + "ERR_UNKNOWN_SIGNAL", + `Unknown signal: ${x}`, + ); + } +} +export class ERR_UNSUPPORTED_DIR_IMPORT extends NodeError { + constructor(x: string, y: string) { + super( + "ERR_UNSUPPORTED_DIR_IMPORT", + `Directory import '${x}' is not supported resolving ES modules, imported from ${y}`, + ); + } +} +export class ERR_UNSUPPORTED_ESM_URL_SCHEME extends NodeError { + constructor() { + super( + "ERR_UNSUPPORTED_ESM_URL_SCHEME", + `Only file and data URLs are supported by the default ESM loader`, + ); + } +} +export class ERR_V8BREAKITERATOR extends NodeError { + constructor() { + super( + "ERR_V8BREAKITERATOR", + `Full ICU data not installed. See https://github.com/nodejs/node/wiki/Intl`, + ); + } +} +export class ERR_VALID_PERFORMANCE_ENTRY_TYPE extends NodeError { + constructor() { + super( + "ERR_VALID_PERFORMANCE_ENTRY_TYPE", + `At least one valid performance entry type is required`, + ); + } +} +export class ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING extends NodeTypeError { + constructor() { + super( + "ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING", + `A dynamic import callback was not specified.`, + ); + } +} +export class ERR_VM_MODULE_ALREADY_LINKED extends NodeError { + constructor() { + super( + "ERR_VM_MODULE_ALREADY_LINKED", + `Module has already been linked`, + ); + } +} +export class ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA extends NodeError { + constructor() { + super( + "ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA", + `Cached data cannot be created for a module which has been evaluated`, + ); + } +} +export class ERR_VM_MODULE_DIFFERENT_CONTEXT extends NodeError { + constructor() { + super( + "ERR_VM_MODULE_DIFFERENT_CONTEXT", + `Linked modules must use the same context`, + ); + } +} +export class ERR_VM_MODULE_LINKING_ERRORED extends NodeError { + constructor() { + super( + "ERR_VM_MODULE_LINKING_ERRORED", + `Linking has already failed for the provided module`, + ); + } +} +export class ERR_VM_MODULE_NOT_MODULE extends NodeError { + constructor() { + super( + "ERR_VM_MODULE_NOT_MODULE", + `Provided module is not an instance of Module`, + ); + } +} +export class ERR_VM_MODULE_STATUS extends NodeError { + constructor(x: string) { + super( + "ERR_VM_MODULE_STATUS", + `Module status ${x}`, + ); + } +} +export class ERR_WASI_ALREADY_STARTED extends NodeError { + constructor() { + super( + "ERR_WASI_ALREADY_STARTED", + `WASI instance has already started`, + ); + } +} +export class ERR_WORKER_INIT_FAILED extends NodeError { + constructor(x: string) { + super( + "ERR_WORKER_INIT_FAILED", + `Worker initialization failure: ${x}`, + ); + } +} +export class ERR_WORKER_NOT_RUNNING extends NodeError { + constructor() { + super( + "ERR_WORKER_NOT_RUNNING", + `Worker instance not running`, + ); + } +} +export class ERR_WORKER_OUT_OF_MEMORY extends NodeError { + constructor(x: string) { + super( + "ERR_WORKER_OUT_OF_MEMORY", + `Worker terminated due to reaching memory limit: ${x}`, + ); + } +} +export class ERR_WORKER_UNSERIALIZABLE_ERROR extends NodeError { + constructor() { + super( + "ERR_WORKER_UNSERIALIZABLE_ERROR", + `Serializing an uncaught exception failed`, + ); + } +} +export class ERR_WORKER_UNSUPPORTED_EXTENSION extends NodeTypeError { + constructor(x: string) { + super( + "ERR_WORKER_UNSUPPORTED_EXTENSION", + `The worker script extension must be ".js", ".mjs", or ".cjs". Received "${x}"`, + ); + } +} +export class ERR_WORKER_UNSUPPORTED_OPERATION extends NodeTypeError { + constructor(x: string) { + super( + "ERR_WORKER_UNSUPPORTED_OPERATION", + `${x} is not supported in workers`, + ); + } +} +export class ERR_ZLIB_INITIALIZATION_FAILED extends NodeError { + constructor() { + super( + "ERR_ZLIB_INITIALIZATION_FAILED", + `Initialization failed`, + ); + } +} +export class ERR_FALSY_VALUE_REJECTION extends NodeError { + reason: string; + constructor(reason: string) { + super( + "ERR_FALSY_VALUE_REJECTION", + "Promise was rejected with falsy value", + ); + this.reason = reason; + } +} +export class ERR_HTTP2_INVALID_SETTING_VALUE extends NodeRangeError { + actual: unknown; + min?: number; + max?: number; + + constructor(name: string, actual: unknown, min?: number, max?: number) { + super( + "ERR_HTTP2_INVALID_SETTING_VALUE", + `Invalid value for setting "${name}": ${actual}`, + ); + this.actual = actual; + if (min !== undefined) { + this.min = min; + this.max = max; + } + } +} +export class ERR_HTTP2_STREAM_CANCEL extends NodeError { + cause?: Error; + constructor(error: Error) { + super( + "ERR_HTTP2_STREAM_CANCEL", + typeof error.message === "string" + ? `The pending stream has been canceled (caused by: ${error.message})` + : "The pending stream has been canceled", + ); + if (error) { + this.cause = error; + } + } +} + +export class ERR_INVALID_ADDRESS_FAMILY extends NodeRangeError { + host: string; + port: number; + constructor(addressType: string, host: string, port: number) { + super( + "ERR_INVALID_ADDRESS_FAMILY", + `Invalid address family: ${addressType} ${host}:${port}`, + ); + this.host = host; + this.port = port; + } +} + +export class ERR_INVALID_CHAR extends NodeTypeError { + constructor(name: string, field?: string) { + super( + "ERR_INVALID_CHAR", + field + ? `Invalid character in ${name}` + : `Invalid character in ${name} ["${field}"]`, + ); + } +} export class ERR_INVALID_OPT_VALUE extends NodeTypeError { constructor(name: string, value: unknown) { @@ -481,3 +2217,54 @@ export class ERR_INVALID_OPT_VALUE extends NodeTypeError { ); } } + +export class ERR_INVALID_RETURN_PROPERTY extends NodeTypeError { + constructor(input: string, name: string, prop: string, value: string) { + super( + "ERR_INVALID_RETURN_PROPERTY", + `Expected a valid ${input} to be returned for the "${prop}" from the "${name}" function but got ${value}.`, + ); + } +} + +// deno-lint-ignore no-explicit-any +function buildReturnPropertyType(value: any) { + if (value && value.constructor && value.constructor.name) { + return `instance of ${value.constructor.name}`; + } else { + return `type ${typeof value}`; + } +} + +export class ERR_INVALID_RETURN_PROPERTY_VALUE extends NodeTypeError { + constructor(input: string, name: string, prop: string, value: unknown) { + super( + "ERR_INVALID_RETURN_PROPERTY_VALUE", + `Expected ${input} to be returned for the "${prop}" from the "${name}" function but got ${ + buildReturnPropertyType(value) + }.`, + ); + } +} + +export class ERR_INVALID_RETURN_VALUE extends NodeTypeError { + constructor(input: string, name: string, value: unknown) { + super( + "ERR_INVALID_RETURN_VALUE", + `Expected ${input} to be returned from the "${name}" function but got ${ + buildReturnPropertyType(value) + }.`, + ); + } +} + +export class ERR_INVALID_URL extends NodeTypeError { + input: string; + constructor(input: string) { + super( + "ERR_INVALID_URL", + `Invalid URL: ${input}`, + ); + this.input = input; + } +}