Merge branch 'denoland:main' into main

1 files changed, 1647 insertions, 4 deletions

diff --git a/runtime/errors.rs b/runtime/errors.rs
index 4c6aeab98..4268fbd50 100644
--- a/runtime/errors.rs
+++ b/runtime/errors.rs
@@ -9,6 +9,16 @@
 //!   Diagnostics are compile-time type errors, whereas JsErrors are runtime
 //!   exceptions.
 
+use crate::ops::fs_events::FsEventsError;
+use crate::ops::http::HttpStartError;
+use crate::ops::os::OsError;
+use crate::ops::permissions::PermissionError;
+use crate::ops::process::CheckRunPermissionError;
+use crate::ops::process::ProcessError;
+use crate::ops::signal::SignalError;
+use crate::ops::tty::TtyError;
+use crate::ops::web_worker::SyncFetchError;
+use crate::ops::worker_host::CreateWorkerError;
 use deno_broadcast_channel::BroadcastChannelError;
 use deno_cache::CacheError;
 use deno_canvas::CanvasError;
@@ -17,12 +27,100 @@ use deno_core::serde_json;
 use deno_core::url;
 use deno_core::ModuleResolutionError;
 use deno_cron::CronError;
+use deno_crypto::DecryptError;
+use deno_crypto::EncryptError;
+use deno_crypto::ExportKeyError;
+use deno_crypto::GenerateKeyError;
+use deno_crypto::ImportKeyError;
+use deno_fetch::FetchError;
+use deno_fetch::HttpClientCreateError;
+use deno_ffi::CallError;
+use deno_ffi::CallbackError;
+use deno_ffi::DlfcnError;
+use deno_ffi::IRError;
+use deno_ffi::ReprError;
+use deno_ffi::StaticError;
+use deno_fs::FsOpsError;
+use deno_fs::FsOpsErrorKind;
+use deno_http::HttpError;
+use deno_http::HttpNextError;
+use deno_http::WebSocketUpgradeError;
+use deno_io::fs::FsError;
+use deno_kv::KvCheckError;
+use deno_kv::KvError;
+use deno_kv::KvErrorKind;
+use deno_kv::KvMutationError;
+use deno_napi::NApiError;
+use deno_net::ops::NetError;
+use deno_permissions::ChildPermissionError;
+use deno_permissions::NetDescriptorFromUrlParseError;
+use deno_permissions::PathResolveError;
+use deno_permissions::PermissionCheckError;
+use deno_permissions::RunDescriptorParseError;
+use deno_permissions::SysDescriptorParseError;
 use deno_tls::TlsError;
+use deno_web::BlobError;
+use deno_web::CompressionError;
+use deno_web::MessagePortError;
+use deno_web::StreamResourceError;
+use deno_web::WebError;
+use deno_websocket::HandshakeError;
+use deno_websocket::WebsocketError;
+use deno_webstorage::WebStorageError;
+use rustyline::error::ReadlineError;
 use std::env;
 use std::error::Error;
 use std::io;
 use std::sync::Arc;
 
+fn get_run_descriptor_parse_error(e: &RunDescriptorParseError) -> &'static str {
+  match e {
+    RunDescriptorParseError::Which(_) => "Error",
+    RunDescriptorParseError::PathResolve(e) => get_path_resolve_error(e),
+    RunDescriptorParseError::EmptyRunQuery => "Error",
+  }
+}
+
+fn get_sys_descriptor_parse_error(e: &SysDescriptorParseError) -> &'static str {
+  match e {
+    SysDescriptorParseError::InvalidKind(_) => "TypeError",
+    SysDescriptorParseError::Empty => "Error",
+  }
+}
+
+fn get_path_resolve_error(e: &PathResolveError) -> &'static str {
+  match e {
+    PathResolveError::CwdResolve(e) => get_io_error_class(e),
+    PathResolveError::EmptyPath => "Error",
+  }
+}
+
+fn get_permission_error_class(e: &PermissionError) -> &'static str {
+  match e {
+    PermissionError::InvalidPermissionName(_) => "ReferenceError",
+    PermissionError::PathResolve(e) => get_path_resolve_error(e),
+    PermissionError::NetDescriptorParse(_) => "URIError",
+    PermissionError::SysDescriptorParse(e) => get_sys_descriptor_parse_error(e),
+    PermissionError::RunDescriptorParse(e) => get_run_descriptor_parse_error(e),
+  }
+}
+
+fn get_permission_check_error_class(e: &PermissionCheckError) -> &'static str {
+  match e {
+    PermissionCheckError::PermissionDenied(_) => "NotCapable",
+    PermissionCheckError::InvalidFilePath(_) => "URIError",
+    PermissionCheckError::NetDescriptorForUrlParse(e) => match e {
+      NetDescriptorFromUrlParseError::MissingHost(_) => "TypeError",
+      NetDescriptorFromUrlParseError::Host(_) => "URIError",
+    },
+    PermissionCheckError::SysDescriptorParse(e) => {
+      get_sys_descriptor_parse_error(e)
+    }
+    PermissionCheckError::PathResolve(e) => get_path_resolve_error(e),
+    PermissionCheckError::HostParse(_) => "URIError",
+  }
+}
+
 fn get_dlopen_error_class(error: &dlopen2::Error) -> &'static str {
   use dlopen2::Error::*;
   match error {
@@ -158,6 +256,381 @@ pub fn get_nix_error_class(error: &nix::Error) -> &'static str {
   }
 }
 
+fn get_webgpu_error_class(e: &deno_webgpu::InitError) -> &'static str {
+  match e {
+    deno_webgpu::InitError::Resource(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+    deno_webgpu::InitError::InvalidAdapter(_) => "Error",
+    deno_webgpu::InitError::RequestDevice(_) => "DOMExceptionOperationError",
+    deno_webgpu::InitError::InvalidDevice(_) => "Error",
+  }
+}
+
+fn get_webgpu_buffer_error_class(
+  e: &deno_webgpu::buffer::BufferError,
+) -> &'static str {
+  match e {
+    deno_webgpu::buffer::BufferError::Resource(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+    deno_webgpu::buffer::BufferError::InvalidUsage => "TypeError",
+    deno_webgpu::buffer::BufferError::Access(_) => "DOMExceptionOperationError",
+  }
+}
+
+fn get_webgpu_bundle_error_class(
+  e: &deno_webgpu::bundle::BundleError,
+) -> &'static str {
+  match e {
+    deno_webgpu::bundle::BundleError::Resource(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+    deno_webgpu::bundle::BundleError::InvalidSize => "TypeError",
+  }
+}
+
+fn get_webgpu_byow_error_class(
+  e: &deno_webgpu::byow::ByowError,
+) -> &'static str {
+  match e {
+    deno_webgpu::byow::ByowError::WebGPUNotInitiated => "TypeError",
+    deno_webgpu::byow::ByowError::InvalidParameters => "TypeError",
+    deno_webgpu::byow::ByowError::CreateSurface(_) => "Error",
+    deno_webgpu::byow::ByowError::InvalidSystem => "TypeError",
+    #[cfg(any(
+      target_os = "windows",
+      target_os = "linux",
+      target_os = "freebsd",
+      target_os = "openbsd"
+    ))]
+    deno_webgpu::byow::ByowError::NullWindow => "TypeError",
+    #[cfg(any(
+      target_os = "linux",
+      target_os = "freebsd",
+      target_os = "openbsd"
+    ))]
+    deno_webgpu::byow::ByowError::NullDisplay => "TypeError",
+    #[cfg(target_os = "macos")]
+    deno_webgpu::byow::ByowError::NSViewDisplay => "TypeError",
+  }
+}
+
+fn get_webgpu_render_pass_error_class(
+  e: &deno_webgpu::render_pass::RenderPassError,
+) -> &'static str {
+  match e {
+    deno_webgpu::render_pass::RenderPassError::Resource(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+    deno_webgpu::render_pass::RenderPassError::InvalidSize => "TypeError",
+  }
+}
+
+fn get_webgpu_surface_error_class(
+  e: &deno_webgpu::surface::SurfaceError,
+) -> &'static str {
+  match e {
+    deno_webgpu::surface::SurfaceError::Resource(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+    deno_webgpu::surface::SurfaceError::Surface(_) => "Error",
+    deno_webgpu::surface::SurfaceError::InvalidStatus => "Error",
+  }
+}
+
+fn get_crypto_decrypt_error_class(e: &DecryptError) -> &'static str {
+  match e {
+    DecryptError::General(e) => get_crypto_shared_error_class(e),
+    DecryptError::Pkcs1(_) => "Error",
+    DecryptError::Failed => "DOMExceptionOperationError",
+    DecryptError::InvalidLength => "TypeError",
+    DecryptError::InvalidCounterLength => "TypeError",
+    DecryptError::InvalidTagLength => "TypeError",
+    DecryptError::InvalidKeyOrIv => "DOMExceptionOperationError",
+    DecryptError::TooMuchData => "DOMExceptionOperationError",
+    DecryptError::InvalidIvLength => "TypeError",
+    DecryptError::Rsa(_) => "DOMExceptionOperationError",
+  }
+}
+
+fn get_crypto_encrypt_error_class(e: &EncryptError) -> &'static str {
+  match e {
+    EncryptError::General(e) => get_crypto_shared_error_class(e),
+    EncryptError::InvalidKeyOrIv => "DOMExceptionOperationError",
+    EncryptError::Failed => "DOMExceptionOperationError",
+    EncryptError::InvalidLength => "TypeError",
+    EncryptError::InvalidIvLength => "TypeError",
+    EncryptError::InvalidCounterLength => "TypeError",
+    EncryptError::TooMuchData => "DOMExceptionOperationError",
+  }
+}
+
+fn get_crypto_shared_error_class(e: &deno_crypto::SharedError) -> &'static str {
+  match e {
+    deno_crypto::SharedError::ExpectedValidPrivateKey => "TypeError",
+    deno_crypto::SharedError::ExpectedValidPublicKey => "TypeError",
+    deno_crypto::SharedError::ExpectedValidPrivateECKey => "TypeError",
+    deno_crypto::SharedError::ExpectedValidPublicECKey => "TypeError",
+    deno_crypto::SharedError::ExpectedPrivateKey => "TypeError",
+    deno_crypto::SharedError::ExpectedPublicKey => "TypeError",
+    deno_crypto::SharedError::ExpectedSecretKey => "TypeError",
+    deno_crypto::SharedError::FailedDecodePrivateKey => {
+      "DOMExceptionOperationError"
+    }
+    deno_crypto::SharedError::FailedDecodePublicKey => {
+      "DOMExceptionOperationError"
+    }
+    deno_crypto::SharedError::UnsupportedFormat => {
+      "DOMExceptionNotSupportedError"
+    }
+  }
+}
+
+fn get_crypto_ed25519_error_class(
+  e: &deno_crypto::Ed25519Error,
+) -> &'static str {
+  match e {
+    deno_crypto::Ed25519Error::FailedExport => "DOMExceptionOperationError",
+    deno_crypto::Ed25519Error::Der(_) => "Error",
+    deno_crypto::Ed25519Error::KeyRejected(_) => "Error",
+  }
+}
+
+fn get_crypto_export_key_error_class(e: &ExportKeyError) -> &'static str {
+  match e {
+    ExportKeyError::General(e) => get_crypto_shared_error_class(e),
+    ExportKeyError::Der(_) => "Error",
+    ExportKeyError::UnsupportedNamedCurve => "DOMExceptionNotSupportedError",
+  }
+}
+
+fn get_crypto_generate_key_error_class(e: &GenerateKeyError) -> &'static str {
+  match e {
+    GenerateKeyError::General(e) => get_crypto_shared_error_class(e),
+    GenerateKeyError::BadPublicExponent => "DOMExceptionOperationError",
+    GenerateKeyError::InvalidHMACKeyLength => "DOMExceptionOperationError",
+    GenerateKeyError::FailedRSAKeySerialization => "DOMExceptionOperationError",
+    GenerateKeyError::InvalidAESKeyLength => "DOMExceptionOperationError",
+    GenerateKeyError::FailedRSAKeyGeneration => "DOMExceptionOperationError",
+    GenerateKeyError::FailedECKeyGeneration => "DOMExceptionOperationError",
+    GenerateKeyError::FailedKeyGeneration => "DOMExceptionOperationError",
+  }
+}
+
+fn get_crypto_import_key_error_class(e: &ImportKeyError) -> &'static str {
+  match e {
+    ImportKeyError::General(e) => get_crypto_shared_error_class(e),
+    ImportKeyError::InvalidModulus => "DOMExceptionDataError",
+    ImportKeyError::InvalidPublicExponent => "DOMExceptionDataError",
+    ImportKeyError::InvalidPrivateExponent => "DOMExceptionDataError",
+    ImportKeyError::InvalidFirstPrimeFactor => "DOMExceptionDataError",
+    ImportKeyError::InvalidSecondPrimeFactor => "DOMExceptionDataError",
+    ImportKeyError::InvalidFirstCRTExponent => "DOMExceptionDataError",
+    ImportKeyError::InvalidSecondCRTExponent => "DOMExceptionDataError",
+    ImportKeyError::InvalidCRTCoefficient => "DOMExceptionDataError",
+    ImportKeyError::InvalidB64Coordinate => "DOMExceptionDataError",
+    ImportKeyError::InvalidRSAPublicKey => "DOMExceptionDataError",
+    ImportKeyError::InvalidRSAPrivateKey => "DOMExceptionDataError",
+    ImportKeyError::UnsupportedAlgorithm => "DOMExceptionDataError",
+    ImportKeyError::PublicKeyTooLong => "DOMExceptionDataError",
+    ImportKeyError::PrivateKeyTooLong => "DOMExceptionDataError",
+    ImportKeyError::InvalidP256ECPoint => "DOMExceptionDataError",
+    ImportKeyError::InvalidP384ECPoint => "DOMExceptionDataError",
+    ImportKeyError::InvalidP521ECPoint => "DOMExceptionDataError",
+    ImportKeyError::UnsupportedNamedCurve => "DOMExceptionDataError",
+    ImportKeyError::CurveMismatch => "DOMExceptionDataError",
+    ImportKeyError::InvalidKeyData => "DOMExceptionDataError",
+    ImportKeyError::InvalidJWKPrivateKey => "DOMExceptionDataError",
+    ImportKeyError::EllipticCurve(_) => "DOMExceptionDataError",
+    ImportKeyError::ExpectedValidPkcs8Data => "DOMExceptionDataError",
+    ImportKeyError::MalformedParameters => "DOMExceptionDataError",
+    ImportKeyError::Spki(_) => "DOMExceptionDataError",
+    ImportKeyError::InvalidP256ECSPKIData => "DOMExceptionDataError",
+    ImportKeyError::InvalidP384ECSPKIData => "DOMExceptionDataError",
+    ImportKeyError::InvalidP521ECSPKIData => "DOMExceptionDataError",
+    ImportKeyError::Der(_) => "DOMExceptionDataError",
+  }
+}
+
+fn get_crypto_x448_error_class(e: &deno_crypto::X448Error) -> &'static str {
+  match e {
+    deno_crypto::X448Error::FailedExport => "DOMExceptionOperationError",
+    deno_crypto::X448Error::Der(_) => "Error",
+  }
+}
+
+fn get_crypto_x25519_error_class(e: &deno_crypto::X25519Error) -> &'static str {
+  match e {
+    deno_crypto::X25519Error::FailedExport => "DOMExceptionOperationError",
+    deno_crypto::X25519Error::Der(_) => "Error",
+  }
+}
+
+fn get_crypto_error_class(e: &deno_crypto::Error) -> &'static str {
+  match e {
+    deno_crypto::Error::Der(_) => "Error",
+    deno_crypto::Error::JoinError(_) => "Error",
+    deno_crypto::Error::MissingArgumentHash => "TypeError",
+    deno_crypto::Error::MissingArgumentSaltLength => "TypeError",
+    deno_crypto::Error::Other(e) => get_error_class_name(e).unwrap_or("Error"),
+    deno_crypto::Error::UnsupportedAlgorithm => "TypeError",
+    deno_crypto::Error::KeyRejected(_) => "Error",
+    deno_crypto::Error::RSA(_) => "Error",
+    deno_crypto::Error::Pkcs1(_) => "Error",
+    deno_crypto::Error::Unspecified(_) => "Error",
+    deno_crypto::Error::InvalidKeyFormat => "TypeError",
+    deno_crypto::Error::MissingArgumentPublicKey => "TypeError",
+    deno_crypto::Error::P256Ecdsa(_) => "Error",
+    deno_crypto::Error::DecodePrivateKey => "TypeError",
+    deno_crypto::Error::MissingArgumentNamedCurve => "TypeError",
+    deno_crypto::Error::MissingArgumentInfo => "TypeError",
+    deno_crypto::Error::HKDFLengthTooLarge => "DOMExceptionOperationError",
+    deno_crypto::Error::General(e) => get_crypto_shared_error_class(e),
+    deno_crypto::Error::Base64Decode(_) => "Error",
+    deno_crypto::Error::DataInvalidSize => "TypeError",
+    deno_crypto::Error::InvalidKeyLength => "TypeError",
+    deno_crypto::Error::EncryptionError => "DOMExceptionOperationError",
+    deno_crypto::Error::DecryptionError => "DOMExceptionOperationError",
+    deno_crypto::Error::ArrayBufferViewLengthExceeded(_) => {
+      "DOMExceptionQuotaExceededError"
+    }
+  }
+}
+
+fn get_napi_error_class(e: &NApiError) -> &'static str {
+  match e {
+    NApiError::InvalidPath
+    | NApiError::LibLoading(_)
+    | NApiError::ModuleNotFound(_) => "TypeError",
+    NApiError::Permission(e) => get_permission_check_error_class(e),
+  }
+}
+
+fn get_web_error_class(e: &WebError) -> &'static str {
+  match e {
+    WebError::Base64Decode => "DOMExceptionInvalidCharacterError",
+    WebError::InvalidEncodingLabel(_) => "RangeError",
+    WebError::BufferTooLong => "TypeError",
+    WebError::ValueTooLarge => "RangeError",
+    WebError::BufferTooSmall => "RangeError",
+    WebError::DataInvalid => "TypeError",
+    WebError::DataError(_) => "Error",
+  }
+}
+
+fn get_web_compression_error_class(e: &CompressionError) -> &'static str {
+  match e {
+    CompressionError::UnsupportedFormat => "TypeError",
+    CompressionError::ResourceClosed => "TypeError",
+    CompressionError::IoTypeError(_) => "TypeError",
+    CompressionError::Io(e) => get_io_error_class(e),
+  }
+}
+
+fn get_web_message_port_error_class(e: &MessagePortError) -> &'static str {
+  match e {
+    MessagePortError::InvalidTransfer => "TypeError",
+    MessagePortError::NotReady => "TypeError",
+    MessagePortError::TransferSelf => "TypeError",
+    MessagePortError::Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+    MessagePortError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+  }
+}
+
+fn get_web_stream_resource_error_class(
+  e: &StreamResourceError,
+) -> &'static str {
+  match e {
+    StreamResourceError::Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+    StreamResourceError::Js(_) => "TypeError",
+  }
+}
+
+fn get_web_blob_error_class(e: &BlobError) -> &'static str {
+  match e {
+    BlobError::BlobPartNotFound => "TypeError",
+    BlobError::SizeLargerThanBlobPart => "TypeError",
+    BlobError::BlobURLsNotSupported => "TypeError",
+    BlobError::Url(_) => "Error",
+  }
+}
+
+fn get_ffi_repr_error_class(e: &ReprError) -> &'static str {
+  match e {
+    ReprError::InvalidOffset => "TypeError",
+    ReprError::InvalidArrayBuffer => "TypeError",
+    ReprError::DestinationLengthTooShort => "RangeError",
+    ReprError::InvalidCString => "TypeError",
+    ReprError::CStringTooLong => "TypeError",
+    ReprError::InvalidBool => "TypeError",
+    ReprError::InvalidU8 => "TypeError",
+    ReprError::InvalidI8 => "TypeError",
+    ReprError::InvalidU16 => "TypeError",
+    ReprError::InvalidI16 => "TypeError",
+    ReprError::InvalidU32 => "TypeError",
+    ReprError::InvalidI32 => "TypeError",
+    ReprError::InvalidU64 => "TypeError",
+    ReprError::InvalidI64 => "TypeError",
+    ReprError::InvalidF32 => "TypeError",
+    ReprError::InvalidF64 => "TypeError",
+    ReprError::InvalidPointer => "TypeError",
+    ReprError::Permission(e) => get_permission_check_error_class(e),
+  }
+}
+
+fn get_ffi_dlfcn_error_class(e: &DlfcnError) -> &'static str {
+  match e {
+    DlfcnError::RegisterSymbol { .. } => "Error",
+    DlfcnError::Dlopen(_) => "Error",
+    DlfcnError::Permission(e) => get_permission_check_error_class(e),
+    DlfcnError::Other(e) => get_error_class_name(e).unwrap_or("Error"),
+  }
+}
+
+fn get_ffi_static_error_class(e: &StaticError) -> &'static str {
+  match e {
+    StaticError::Dlfcn(e) => get_ffi_dlfcn_error_class(e),
+    StaticError::InvalidTypeVoid => "TypeError",
+    StaticError::InvalidTypeStruct => "TypeError",
+    StaticError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+  }
+}
+
+fn get_ffi_callback_error_class(e: &CallbackError) -> &'static str {
+  match e {
+    CallbackError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+    CallbackError::Other(e) => get_error_class_name(e).unwrap_or("Error"),
+    CallbackError::Permission(e) => get_permission_check_error_class(e),
+  }
+}
+
+fn get_ffi_call_error_class(e: &CallError) -> &'static str {
+  match e {
+    CallError::IR(_) => "TypeError",
+    CallError::NonblockingCallFailure(_) => "Error",
+    CallError::InvalidSymbol(_) => "TypeError",
+    CallError::Permission(e) => get_permission_check_error_class(e),
+    CallError::Callback(e) => get_ffi_callback_error_class(e),
+    CallError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+  }
+}
+
+fn get_webstorage_class_name(e: &WebStorageError) -> &'static str {
+  match e {
+    WebStorageError::ContextNotSupported => "DOMExceptionNotSupportedError",
+    WebStorageError::Sqlite(_) => "Error",
+    WebStorageError::Io(e) => get_io_error_class(e),
+    WebStorageError::StorageExceeded => "DOMExceptionQuotaExceededError",
+  }
+}
+
 fn get_tls_error_class(e: &TlsError) -> &'static str {
   match e {
     TlsError::Rustls(_) => "Error",
@@ -217,21 +690,1191 @@ fn get_broadcast_channel_error(error: &BroadcastChannelError) -> &'static str {
   }
 }
 
+fn get_fetch_error(error: &FetchError) -> &'static str {
+  match error {
+    FetchError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+    FetchError::Permission(e) => get_permission_check_error_class(e),
+    FetchError::NetworkError => "TypeError",
+    FetchError::FsNotGet(_) => "TypeError",
+    FetchError::InvalidUrl(_) => "TypeError",
+    FetchError::InvalidHeaderName(_) => "TypeError",
+    FetchError::InvalidHeaderValue(_) => "TypeError",
+    FetchError::DataUrl(_) => "TypeError",
+    FetchError::Base64(_) => "TypeError",
+    FetchError::BlobNotFound => "TypeError",
+    FetchError::SchemeNotSupported(_) => "TypeError",
+    FetchError::RequestCanceled => "TypeError",
+    FetchError::Http(_) => "Error",
+    FetchError::ClientCreate(e) => get_http_client_create_error(e),
+    FetchError::Url(e) => get_url_parse_error_class(e),
+    FetchError::Method(_) => "TypeError",
+    FetchError::ClientSend(_) => "TypeError",
+    FetchError::RequestBuilderHook(_) => "TypeError",
+    FetchError::Io(e) => get_io_error_class(e),
+    FetchError::Hyper(e) => get_hyper_error_class(e),
+  }
+}
+
+fn get_http_client_create_error(error: &HttpClientCreateError) -> &'static str {
+  match error {
+    HttpClientCreateError::Tls(_) => "TypeError",
+    HttpClientCreateError::InvalidUserAgent(_) => "TypeError",
+    HttpClientCreateError::InvalidProxyUrl => "TypeError",
+    HttpClientCreateError::HttpVersionSelectionInvalid => "TypeError",
+    HttpClientCreateError::RootCertStore(_) => "TypeError",
+  }
+}
+
+fn get_websocket_error(error: &WebsocketError) -> &'static str {
+  match error {
+    WebsocketError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+    WebsocketError::Permission(e) => get_permission_check_error_class(e),
+    WebsocketError::Url(e) => get_url_parse_error_class(e),
+    WebsocketError::Io(e) => get_io_error_class(e),
+    WebsocketError::WebSocket(_) => "TypeError",
+    WebsocketError::ConnectionFailed(_) => "DOMExceptionNetworkError",
+    WebsocketError::Uri(_) => "Error",
+    WebsocketError::Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+  }
+}
+
+fn get_websocket_handshake_error(error: &HandshakeError) -> &'static str {
+  match error {
+    HandshakeError::RootStoreError(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+    HandshakeError::Tls(e) => get_tls_error_class(e),
+    HandshakeError::MissingPath => "TypeError",
+    HandshakeError::Http(_) => "Error",
+    HandshakeError::InvalidHostname(_) => "TypeError",
+    HandshakeError::Io(e) => get_io_error_class(e),
+    HandshakeError::Rustls(_) => "Error",
+    HandshakeError::H2(_) => "Error",
+    HandshakeError::NoH2Alpn => "Error",
+    HandshakeError::InvalidStatusCode(_) => "Error",
+    HandshakeError::WebSocket(_) => "TypeError",
+    HandshakeError::HeaderName(_) => "TypeError",
+    HandshakeError::HeaderValue(_) => "TypeError",
+  }
+}
+
+fn get_fs_ops_error(error: &FsOpsError) -> &'static str {
+  use FsOpsErrorKind::*;
+  match error.as_kind() {
+    Io(e) => get_io_error_class(e),
+    OperationError(e) => get_fs_error(&e.err),
+    Permission(e) => get_permission_check_error_class(e),
+    Resource(e) | Other(e) => get_error_class_name(e).unwrap_or("Error"),
+    InvalidUtf8(_) => "InvalidData",
+    StripPrefix(_) => "Error",
+    Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+    InvalidSeekMode(_) => "TypeError",
+    InvalidControlCharacter(_) => "Error",
+    InvalidCharacter(_) => "Error",
+    #[cfg(windows)]
+    InvalidTrailingCharacter => "Error",
+    NotCapableAccess { .. } => "NotCapable",
+    NotCapable(_) => "NotCapable",
+  }
+}
+
+fn get_kv_error(error: &KvError) -> &'static str {
+  use KvErrorKind::*;
+  match error.as_kind() {
+    DatabaseHandler(e) | Resource(e) | Kv(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+    TooManyRanges(_) => "TypeError",
+    TooManyEntries(_) => "TypeError",
+    TooManyChecks(_) => "TypeError",
+    TooManyMutations(_) => "TypeError",
+    TooManyKeys(_) => "TypeError",
+    InvalidLimit => "TypeError",
+    InvalidBoundaryKey => "TypeError",
+    KeyTooLargeToRead(_) => "TypeError",
+    KeyTooLargeToWrite(_) => "TypeError",
+    TotalMutationTooLarge(_) => "TypeError",
+    TotalKeyTooLarge(_) => "TypeError",
+    Io(e) => get_io_error_class(e),
+    QueueMessageNotFound => "TypeError",
+    StartKeyNotInKeyspace => "TypeError",
+    EndKeyNotInKeyspace => "TypeError",
+    StartKeyGreaterThanEndKey => "TypeError",
+    InvalidCheck(e) => match e {
+      KvCheckError::InvalidVersionstamp => "TypeError",
+      KvCheckError::Io(e) => get_io_error_class(e),
+    },
+    InvalidMutation(e) => match e {
+      KvMutationError::BigInt(_) => "Error",
+      KvMutationError::Io(e) => get_io_error_class(e),
+      KvMutationError::InvalidMutationWithValue(_) => "TypeError",
+      KvMutationError::InvalidMutationWithoutValue(_) => "TypeError",
+    },
+    InvalidEnqueue(e) => get_io_error_class(e),
+    EmptyKey => "TypeError",
+    ValueTooLarge(_) => "TypeError",
+    EnqueuePayloadTooLarge(_) => "TypeError",
+    InvalidCursor => "TypeError",
+    CursorOutOfBounds => "TypeError",
+    InvalidRange => "TypeError",
+  }
+}
+
+fn get_net_error(error: &NetError) -> &'static str {
+  match error {
+    NetError::ListenerClosed => "BadResource",
+    NetError::ListenerBusy => "Busy",
+    NetError::SocketClosed => "BadResource",
+    NetError::SocketClosedNotConnected => "NotConnected",
+    NetError::SocketBusy => "Busy",
+    NetError::Io(e) => get_io_error_class(e),
+    NetError::AcceptTaskOngoing => "Busy",
+    NetError::RootCertStore(e) | NetError::Resource(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+    NetError::Permission(e) => get_permission_check_error_class(e),
+    NetError::NoResolvedAddress => "Error",
+    NetError::AddrParse(_) => "Error",
+    NetError::Map(e) => get_net_map_error(e),
+    NetError::Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+    NetError::DnsNotFound(_) => "NotFound",
+    NetError::DnsNotConnected(_) => "NotConnected",
+    NetError::DnsTimedOut(_) => "TimedOut",
+    NetError::Dns(_) => "Error",
+    NetError::UnsupportedRecordType => "NotSupported",
+    NetError::InvalidUtf8(_) => "InvalidData",
+    NetError::UnexpectedKeyType => "Error",
+    NetError::InvalidHostname(_) => "TypeError",
+    NetError::TcpStreamBusy => "Busy",
+    NetError::Rustls(_) => "Error",
+    NetError::Tls(e) => get_tls_error_class(e),
+    NetError::ListenTlsRequiresKey => "InvalidData",
+    NetError::Reunite(_) => "Error",
+  }
+}
+
+fn get_net_map_error(error: &deno_net::io::MapError) -> &'static str {
+  match error {
+    deno_net::io::MapError::Io(e) => get_io_error_class(e),
+    deno_net::io::MapError::NoResources => "Error",
+  }
+}
+
+fn get_child_permission_error(e: &ChildPermissionError) -> &'static str {
+  match e {
+    ChildPermissionError::Escalation => "NotCapable",
+    ChildPermissionError::PathResolve(e) => get_path_resolve_error(e),
+    ChildPermissionError::NetDescriptorParse(_) => "URIError",
+    ChildPermissionError::EnvDescriptorParse(_) => "Error",
+    ChildPermissionError::SysDescriptorParse(e) => {
+      get_sys_descriptor_parse_error(e)
+    }
+    ChildPermissionError::RunDescriptorParse(e) => {
+      get_run_descriptor_parse_error(e)
+    }
+  }
+}
+
+fn get_create_worker_error(error: &CreateWorkerError) -> &'static str {
+  match error {
+    CreateWorkerError::ClassicWorkers => "DOMExceptionNotSupportedError",
+    CreateWorkerError::Permission(e) => get_child_permission_error(e),
+    CreateWorkerError::ModuleResolution(e) => {
+      get_module_resolution_error_class(e)
+    }
+    CreateWorkerError::Io(e) => get_io_error_class(e),
+    CreateWorkerError::MessagePort(e) => get_web_message_port_error_class(e),
+  }
+}
+
+fn get_tty_error(error: &TtyError) -> &'static str {
+  match error {
+    TtyError::Resource(e) | TtyError::Other(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+    TtyError::Io(e) => get_io_error_class(e),
+    #[cfg(unix)]
+    TtyError::Nix(e) => get_nix_error_class(e),
+  }
+}
+
+fn get_readline_error(error: &ReadlineError) -> &'static str {
+  match error {
+    ReadlineError::Io(e) => get_io_error_class(e),
+    ReadlineError::Eof => "Error",
+    ReadlineError::Interrupted => "Error",
+    #[cfg(unix)]
+    ReadlineError::Errno(e) => get_nix_error_class(e),
+    ReadlineError::WindowResized => "Error",
+    #[cfg(windows)]
+    ReadlineError::Decode(_) => "Error",
+    #[cfg(windows)]
+    ReadlineError::SystemError(_) => "Error",
+    _ => "Error",
+  }
+}
+
+fn get_signal_error(error: &SignalError) -> &'static str {
+  match error {
+    SignalError::InvalidSignalStr(_) => "TypeError",
+    SignalError::InvalidSignalInt(_) => "TypeError",
+    SignalError::SignalNotAllowed(_) => "TypeError",
+    SignalError::Io(e) => get_io_error_class(e),
+  }
+}
+
+fn get_fs_events_error(error: &FsEventsError) -> &'static str {
+  match error {
+    FsEventsError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+    FsEventsError::Permission(e) => get_permission_check_error_class(e),
+    FsEventsError::Notify(e) => get_notify_error_class(e),
+    FsEventsError::Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+  }
+}
+
+fn get_http_start_error(error: &HttpStartError) -> &'static str {
+  match error {
+    HttpStartError::TcpStreamInUse => "Busy",
+    HttpStartError::TlsStreamInUse => "Busy",
+    HttpStartError::UnixSocketInUse => "Busy",
+    HttpStartError::ReuniteTcp(_) => "Error",
+    #[cfg(unix)]
+    HttpStartError::ReuniteUnix(_) => "Error",
+    HttpStartError::Io(e) => get_io_error_class(e),
+    HttpStartError::Other(e) => get_error_class_name(e).unwrap_or("Error"),
+  }
+}
+
+fn get_process_error(error: &ProcessError) -> &'static str {
+  match error {
+    ProcessError::SpawnFailed { error, .. } => get_process_error(error),
+    ProcessError::FailedResolvingCwd(e) | ProcessError::Io(e) => {
+      get_io_error_class(e)
+    }
+    ProcessError::Permission(e) => get_permission_check_error_class(e),
+    ProcessError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+    ProcessError::BorrowMut(_) => "Error",
+    ProcessError::Which(_) => "Error",
+    ProcessError::ChildProcessAlreadyTerminated => "TypeError",
+    ProcessError::Signal(e) => get_signal_error(e),
+    ProcessError::MissingCmd => "Error",
+    ProcessError::InvalidPid => "TypeError",
+    #[cfg(unix)]
+    ProcessError::Nix(e) => get_nix_error_class(e),
+    ProcessError::RunPermission(e) => match e {
+      CheckRunPermissionError::Permission(e) => {
+        get_permission_check_error_class(e)
+      }
+      CheckRunPermissionError::Other(e) => {
+        get_error_class_name(e).unwrap_or("Error")
+      }
+    },
+  }
+}
+
+fn get_http_error(error: &HttpError) -> &'static str {
+  match error {
+    HttpError::Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+    HttpError::HyperV014(e) => get_hyper_v014_error_class(e),
+    HttpError::InvalidHeaderName(_) => "Error",
+    HttpError::InvalidHeaderValue(_) => "Error",
+    HttpError::Http(_) => "Error",
+    HttpError::ResponseHeadersAlreadySent => "Http",
+    HttpError::ConnectionClosedWhileSendingResponse => "Http",
+    HttpError::AlreadyInUse => "Http",
+    HttpError::Io(e) => get_io_error_class(e),
+    HttpError::NoResponseHeaders => "Http",
+    HttpError::ResponseAlreadyCompleted => "Http",
+    HttpError::UpgradeBodyUsed => "Http",
+    HttpError::Resource(e) | HttpError::Other(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+  }
+}
+
+fn get_http_next_error(error: &HttpNextError) -> &'static str {
+  match error {
+    HttpNextError::Io(e) => get_io_error_class(e),
+    HttpNextError::WebSocketUpgrade(e) => get_websocket_upgrade_error(e),
+    HttpNextError::Hyper(e) => get_hyper_error_class(e),
+    HttpNextError::JoinError(_) => "Error",
+    HttpNextError::Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+    HttpNextError::UpgradeUnavailable(_) => "Error",
+    HttpNextError::HttpPropertyExtractor(e) | HttpNextError::Resource(e) => {
+      get_error_class_name(e).unwrap_or("Error")
+    }
+  }
+}
+
+fn get_websocket_upgrade_error(error: &WebSocketUpgradeError) -> &'static str {
+  match error {
+    WebSocketUpgradeError::InvalidHeaders => "Http",
+    WebSocketUpgradeError::HttpParse(_) => "Error",
+    WebSocketUpgradeError::Http(_) => "Error",
+    WebSocketUpgradeError::Utf8(_) => "Error",
+    WebSocketUpgradeError::InvalidHeaderName(_) => "Error",
+    WebSocketUpgradeError::InvalidHeaderValue(_) => "Error",
+    WebSocketUpgradeError::InvalidHttpStatusLine => "Http",
+    WebSocketUpgradeError::UpgradeBufferAlreadyCompleted => "Http",
+  }
+}
+
+fn get_fs_error(e: &FsError) -> &'static str {
+  match &e {
+    FsError::Io(e) => get_io_error_class(e),
+    FsError::FileBusy => "Busy",
+    FsError::NotSupported => "NotSupported",
+    FsError::NotCapable(_) => "NotCapable",
+  }
+}
+
+mod node {
+  use super::get_error_class_name;
+  use super::get_io_error_class;
+  use super::get_permission_check_error_class;
+  use super::get_serde_json_error_class;
+  use super::get_url_parse_error_class;
+  pub use deno_node::ops::blocklist::BlocklistError;
+  pub use deno_node::ops::crypto::cipher::CipherContextError;
+  pub use deno_node::ops::crypto::cipher::CipherError;
+  pub use deno_node::ops::crypto::cipher::DecipherContextError;
+  pub use deno_node::ops::crypto::cipher::DecipherError;
+  pub use deno_node::ops::crypto::digest::HashError;
+  pub use deno_node::ops::crypto::keys::AsymmetricPrivateKeyDerError;
+  pub use deno_node::ops::crypto::keys::AsymmetricPrivateKeyError;
+  pub use deno_node::ops::crypto::keys::AsymmetricPublicKeyDerError;
+  pub use deno_node::ops::crypto::keys::AsymmetricPublicKeyError;
+  pub use deno_node::ops::crypto::keys::AsymmetricPublicKeyJwkError;
+  pub use deno_node::ops::crypto::keys::EcJwkError;
+  pub use deno_node::ops::crypto::keys::EdRawError;
+  pub use deno_node::ops::crypto::keys::ExportPrivateKeyPemError;
+  pub use deno_node::ops::crypto::keys::ExportPublicKeyPemError;
+  pub use deno_node::ops::crypto::keys::GenerateRsaPssError;
+  pub use deno_node::ops::crypto::keys::RsaJwkError;
+  pub use deno_node::ops::crypto::keys::RsaPssParamsParseError;
+  pub use deno_node::ops::crypto::keys::X509PublicKeyError;
+  pub use deno_node::ops::crypto::sign::KeyObjectHandlePrehashedSignAndVerifyError;
+  pub use deno_node::ops::crypto::x509::X509Error;
+  pub use deno_node::ops::crypto::DiffieHellmanError;
+  pub use deno_node::ops::crypto::EcdhEncodePubKey;
+  pub use deno_node::ops::crypto::HkdfError;
+  pub use deno_node::ops::crypto::Pbkdf2Error;
+  pub use deno_node::ops::crypto::PrivateEncryptDecryptError;
+  pub use deno_node::ops::crypto::ScryptAsyncError;
+  pub use deno_node::ops::crypto::SignEd25519Error;
+  pub use deno_node::ops::crypto::VerifyEd25519Error;
+  pub use deno_node::ops::fs::FsError;
+  pub use deno_node::ops::http2::Http2Error;
+  pub use deno_node::ops::idna::IdnaError;
+  pub use deno_node::ops::ipc::IpcError;
+  pub use deno_node::ops::ipc::IpcJsonStreamError;
+  use deno_node::ops::os::priority::PriorityError;
+  pub use deno_node::ops::os::OsError;
+  pub use deno_node::ops::require::RequireError;
+  use deno_node::ops::require::RequireErrorKind;
+  pub use deno_node::ops::worker_threads::WorkerThreadsFilenameError;
+  pub use deno_node::ops::zlib::brotli::BrotliError;
+  pub use deno_node::ops::zlib::mode::ModeError;
+  pub use deno_node::ops::zlib::ZlibError;
+
+  pub fn get_blocklist_error(error: &BlocklistError) -> &'static str {
+    match error {
+      BlocklistError::AddrParse(_) => "Error",
+      BlocklistError::IpNetwork(_) => "Error",
+      BlocklistError::InvalidAddress => "Error",
+      BlocklistError::IpVersionMismatch => "Error",
+    }
+  }
+
+  pub fn get_fs_error(error: &FsError) -> &'static str {
+    match error {
+      FsError::Permission(e) => get_permission_check_error_class(e),
+      FsError::Io(e) => get_io_error_class(e),
+      #[cfg(windows)]
+      FsError::PathHasNoRoot => "Error",
+      #[cfg(not(any(unix, windows)))]
+      FsError::UnsupportedPlatform => "Error",
+      FsError::Fs(e) => super::get_fs_error(e),
+    }
+  }
+
+  pub fn get_idna_error(error: &IdnaError) -> &'static str {
+    match error {
+      IdnaError::InvalidInput => "RangeError",
+      IdnaError::InputTooLong => "Error",
+      IdnaError::IllegalInput => "RangeError",
+    }
+  }
+
+  pub fn get_ipc_json_stream_error(error: &IpcJsonStreamError) -> &'static str {
+    match error {
+      IpcJsonStreamError::Io(e) => get_io_error_class(e),
+      IpcJsonStreamError::SimdJson(_) => "Error",
+    }
+  }
+
+  pub fn get_ipc_error(error: &IpcError) -> &'static str {
+    match error {
+      IpcError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+      IpcError::IpcJsonStream(e) => get_ipc_json_stream_error(e),
+      IpcError::Canceled(e) => {
+        let io_err: std::io::Error = e.to_owned().into();
+        get_io_error_class(&io_err)
+      }
+      IpcError::SerdeJson(e) => get_serde_json_error_class(e),
+    }
+  }
+
+  pub fn get_worker_threads_filename_error(
+    error: &WorkerThreadsFilenameError,
+  ) -> &'static str {
+    match error {
+      WorkerThreadsFilenameError::Permission(e) => {
+        get_error_class_name(e).unwrap_or("Error")
+      }
+      WorkerThreadsFilenameError::UrlParse(e) => get_url_parse_error_class(e),
+      WorkerThreadsFilenameError::InvalidRelativeUrl => "Error",
+      WorkerThreadsFilenameError::UrlFromPathString => "Error",
+      WorkerThreadsFilenameError::UrlToPathString => "Error",
+      WorkerThreadsFilenameError::UrlToPath => "Error",
+      WorkerThreadsFilenameError::FileNotFound(_) => "Error",
+      WorkerThreadsFilenameError::Fs(e) => super::get_fs_error(e),
+    }
+  }
+
+  pub fn get_require_error(error: &RequireError) -> &'static str {
+    use RequireErrorKind::*;
+    match error.as_kind() {
+      UrlParse(e) => get_url_parse_error_class(e),
+      Permission(e) => get_error_class_name(e).unwrap_or("Error"),
+      PackageExportsResolve(_)
+      | PackageJsonLoad(_)
+      | ClosestPkgJson(_)
+      | FilePathConversion(_)
+      | UrlConversion(_)
+      | ReadModule(_)
+      | PackageImportsResolve(_) => "Error",
+      Fs(e) | UnableToGetCwd(e) => super::get_fs_error(e),
+    }
+  }
+
+  pub fn get_http2_error(error: &Http2Error) -> &'static str {
+    match error {
+      Http2Error::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+      Http2Error::UrlParse(e) => get_url_parse_error_class(e),
+      Http2Error::H2(_) => "Error",
+    }
+  }
+
+  pub fn get_os_error(error: &OsError) -> &'static str {
+    match error {
+      OsError::Priority(e) => match e {
+        PriorityError::Io(e) => get_io_error_class(e),
+        #[cfg(windows)]
+        PriorityError::InvalidPriority => "TypeError",
+      },
+      OsError::Permission(e) => get_permission_check_error_class(e),
+      OsError::FailedToGetCpuInfo => "TypeError",
+      OsError::FailedToGetUserInfo(e) => get_io_error_class(e),
+    }
+  }
+
+  pub fn get_brotli_error(error: &BrotliError) -> &'static str {
+    match error {
+      BrotliError::InvalidEncoderMode => "TypeError",
+      BrotliError::CompressFailed => "TypeError",
+      BrotliError::DecompressFailed => "TypeError",
+      BrotliError::Join(_) => "Error",
+      BrotliError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+      BrotliError::Io(e) => get_io_error_class(e),
+    }
+  }
+
+  pub fn get_mode_error(_: &ModeError) -> &'static str {
+    "Error"
+  }
+
+  pub fn get_zlib_error(e: &ZlibError) -> &'static str {
+    match e {
+      ZlibError::NotInitialized => "TypeError",
+      ZlibError::Mode(e) => get_mode_error(e),
+      ZlibError::Other(e) => get_error_class_name(e).unwrap_or("Error"),
+    }
+  }
+
+  pub fn get_crypto_cipher_context_error(
+    e: &CipherContextError,
+  ) -> &'static str {
+    match e {
+      CipherContextError::ContextInUse => "TypeError",
+      CipherContextError::Cipher(e) => get_crypto_cipher_error(e),
+      CipherContextError::Resource(e) => {
+        get_error_class_name(e).unwrap_or("Error")
+      }
+    }
+  }
+
+  pub fn get_crypto_cipher_error(e: &CipherError) -> &'static str {
+    match e {
+      CipherError::InvalidIvLength => "TypeError",
+      CipherError::InvalidKeyLength => "RangeError",
+      CipherError::InvalidInitializationVector => "TypeError",
+      CipherError::CannotPadInputData => "TypeError",
+      CipherError::UnknownCipher(_) => "TypeError",
+    }
+  }
+
+  pub fn get_crypto_decipher_context_error(
+    e: &DecipherContextError,
+  ) -> &'static str {
+    match e {
+      DecipherContextError::ContextInUse => "TypeError",
+      DecipherContextError::Decipher(e) => get_crypto_decipher_error(e),
+      DecipherContextError::Resource(e) => {
+        get_error_class_name(e).unwrap_or("Error")
+      }
+    }
+  }
+
+  pub fn get_crypto_decipher_error(e: &DecipherError) -> &'static str {
+    match e {
+      DecipherError::InvalidIvLength => "TypeError",
+      DecipherError::InvalidKeyLength => "RangeError",
+      DecipherError::InvalidInitializationVector => "TypeError",
+      DecipherError::CannotUnpadInputData => "TypeError",
+      DecipherError::DataAuthenticationFailed => "TypeError",
+      DecipherError::SetAutoPaddingFalseAes128GcmUnsupported => "TypeError",
+      DecipherError::SetAutoPaddingFalseAes256GcmUnsupported => "TypeError",
+      DecipherError::UnknownCipher(_) => "TypeError",
+    }
+  }
+
+  pub fn get_x509_error(_: &X509Error) -> &'static str {
+    "Error"
+  }
+
+  pub fn get_crypto_key_object_handle_prehashed_sign_and_verify_error(
+    e: &KeyObjectHandlePrehashedSignAndVerifyError,
+  ) -> &'static str {
+    match e {
+      KeyObjectHandlePrehashedSignAndVerifyError::InvalidDsaSignatureEncoding => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::KeyIsNotPrivate => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::DigestNotAllowedForRsaSignature(_) => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::FailedToSignDigestWithRsa => "Error",
+      KeyObjectHandlePrehashedSignAndVerifyError::DigestNotAllowedForRsaPssSignature(_) => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::FailedToSignDigestWithRsaPss => "Error",
+      KeyObjectHandlePrehashedSignAndVerifyError::FailedToSignDigestWithDsa => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::RsaPssHashAlgorithmUnsupported => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::PrivateKeyDisallowsUsage { .. } => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::FailedToSignDigest => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::X25519KeyCannotBeUsedForSigning => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::Ed25519KeyCannotBeUsedForPrehashedSigning => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::DhKeyCannotBeUsedForSigning => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::KeyIsNotPublicOrPrivate => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::InvalidDsaSignature => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::X25519KeyCannotBeUsedForVerification => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::Ed25519KeyCannotBeUsedForPrehashedVerification => "TypeError",
+      KeyObjectHandlePrehashedSignAndVerifyError::DhKeyCannotBeUsedForVerification => "TypeError",
+    }
+  }
+
+  pub fn get_crypto_hash_error(_: &HashError) -> &'static str {
+    "Error"
+  }
+
+  pub fn get_asymmetric_public_key_jwk_error(
+    e: &AsymmetricPublicKeyJwkError,
+  ) -> &'static str {
+    match e {
+      AsymmetricPublicKeyJwkError::UnsupportedJwkEcCurveP224 => "TypeError",
+      AsymmetricPublicKeyJwkError::JwkExportNotImplementedForKeyType => {
+        "TypeError"
+      }
+      AsymmetricPublicKeyJwkError::KeyIsNotAsymmetricPublicKey => "TypeError",
+    }
+  }
+
+  pub fn get_generate_rsa_pss_error(_: &GenerateRsaPssError) -> &'static str {
+    "TypeError"
+  }
+
+  pub fn get_asymmetric_private_key_der_error(
+    e: &AsymmetricPrivateKeyDerError,
+  ) -> &'static str {
+    match e {
+      AsymmetricPrivateKeyDerError::KeyIsNotAsymmetricPrivateKey => "TypeError",
+      AsymmetricPrivateKeyDerError::InvalidRsaPrivateKey => "TypeError",
+      AsymmetricPrivateKeyDerError::ExportingNonRsaPrivateKeyAsPkcs1Unsupported => "TypeError",
+      AsymmetricPrivateKeyDerError::InvalidEcPrivateKey => "TypeError",
+      AsymmetricPrivateKeyDerError::ExportingNonEcPrivateKeyAsSec1Unsupported => "TypeError",
+      AsymmetricPrivateKeyDerError::ExportingNonRsaPssPrivateKeyAsPkcs8Unsupported => "Error",
+      AsymmetricPrivateKeyDerError::InvalidDsaPrivateKey => "TypeError",
+      AsymmetricPrivateKeyDerError::InvalidX25519PrivateKey => "TypeError",
+      AsymmetricPrivateKeyDerError::InvalidEd25519PrivateKey => "TypeError",
+      AsymmetricPrivateKeyDerError::InvalidDhPrivateKey => "TypeError",
+      AsymmetricPrivateKeyDerError::UnsupportedKeyType(_) => "TypeError",
+    }
+  }
+
+  pub fn get_asymmetric_public_key_der_error(
+    _: &AsymmetricPublicKeyDerError,
+  ) -> &'static str {
+    "TypeError"
+  }
+
+  pub fn get_export_public_key_pem_error(
+    e: &ExportPublicKeyPemError,
+  ) -> &'static str {
+    match e {
+      ExportPublicKeyPemError::AsymmetricPublicKeyDer(e) => {
+        get_asymmetric_public_key_der_error(e)
+      }
+      ExportPublicKeyPemError::VeryLargeData => "TypeError",
+      ExportPublicKeyPemError::Der(_) => "Error",
+    }
+  }
+
+  pub fn get_export_private_key_pem_error(
+    e: &ExportPrivateKeyPemError,
+  ) -> &'static str {
+    match e {
+      ExportPrivateKeyPemError::AsymmetricPublicKeyDer(e) => {
+        get_asymmetric_private_key_der_error(e)
+      }
+      ExportPrivateKeyPemError::VeryLargeData => "TypeError",
+      ExportPrivateKeyPemError::Der(_) => "Error",
+    }
+  }
+
+  pub fn get_x509_public_key_error(e: &X509PublicKeyError) -> &'static str {
+    match e {
+      X509PublicKeyError::X509(_) => "Error",
+      X509PublicKeyError::Rsa(_) => "Error",
+      X509PublicKeyError::Asn1(_) => "Error",
+      X509PublicKeyError::Ec(_) => "Error",
+      X509PublicKeyError::UnsupportedEcNamedCurve => "TypeError",
+      X509PublicKeyError::MissingEcParameters => "TypeError",
+      X509PublicKeyError::MalformedDssPublicKey => "TypeError",
+      X509PublicKeyError::UnsupportedX509KeyType => "TypeError",
+    }
+  }
+
+  pub fn get_rsa_jwk_error(e: &RsaJwkError) -> &'static str {
+    match e {
+      RsaJwkError::Base64(_) => "Error",
+      RsaJwkError::Rsa(_) => "Error",
+      RsaJwkError::MissingRsaPrivateComponent => "TypeError",
+    }
+  }
+
+  pub fn get_ec_jwk_error(e: &EcJwkError) -> &'static str {
+    match e {
+      EcJwkError::Ec(_) => "Error",
+      EcJwkError::UnsupportedCurve(_) => "TypeError",
+    }
+  }
+
+  pub fn get_ed_raw_error(e: &EdRawError) -> &'static str {
+    match e {
+      EdRawError::Ed25519Signature(_) => "Error",
+      EdRawError::InvalidEd25519Key => "TypeError",
+      EdRawError::UnsupportedCurve => "TypeError",
+    }
+  }
+
+  pub fn get_pbkdf2_error(e: &Pbkdf2Error) -> &'static str {
+    match e {
+      Pbkdf2Error::UnsupportedDigest(_) => "TypeError",
+      Pbkdf2Error::Join(_) => "Error",
+    }
+  }
+
+  pub fn get_scrypt_async_error(e: &ScryptAsyncError) -> &'static str {
+    match e {
+      ScryptAsyncError::Join(_) => "Error",
+      ScryptAsyncError::Other(e) => get_error_class_name(e).unwrap_or("Error"),
+    }
+  }
+
+  pub fn get_hkdf_error_error(e: &HkdfError) -> &'static str {
+    match e {
+      HkdfError::ExpectedSecretKey => "TypeError",
+      HkdfError::HkdfExpandFailed => "TypeError",
+      HkdfError::UnsupportedDigest(_) => "TypeError",
+      HkdfError::Join(_) => "Error",
+    }
+  }
+
+  pub fn get_rsa_pss_params_parse_error(
+    _: &RsaPssParamsParseError,
+  ) -> &'static str {
+    "TypeError"
+  }
+
+  pub fn get_asymmetric_private_key_error(
+    e: &AsymmetricPrivateKeyError,
+  ) -> &'static str {
+    match e {
+      AsymmetricPrivateKeyError::InvalidPemPrivateKeyInvalidUtf8(_) => "TypeError",
+      AsymmetricPrivateKeyError::InvalidEncryptedPemPrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::InvalidPemPrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::EncryptedPrivateKeyRequiresPassphraseToDecrypt => "TypeError",
+      AsymmetricPrivateKeyError::InvalidPkcs1PrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::InvalidSec1PrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::UnsupportedPemLabel(_) => "TypeError",
+      AsymmetricPrivateKeyError::RsaPssParamsParse(e) => get_rsa_pss_params_parse_error(e),
+      AsymmetricPrivateKeyError::InvalidEncryptedPkcs8PrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::InvalidPkcs8PrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::Pkcs1PrivateKeyDoesNotSupportEncryptionWithPassphrase => "TypeError",
+      AsymmetricPrivateKeyError::Sec1PrivateKeyDoesNotSupportEncryptionWithPassphrase => "TypeError",
+      AsymmetricPrivateKeyError::UnsupportedEcNamedCurve => "TypeError",
+      AsymmetricPrivateKeyError::InvalidPrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::InvalidDsaPrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::MalformedOrMissingNamedCurveInEcParameters => "TypeError",
+      AsymmetricPrivateKeyError::UnsupportedKeyType(_) => "TypeError",
+      AsymmetricPrivateKeyError::UnsupportedKeyFormat(_) => "TypeError",
+      AsymmetricPrivateKeyError::InvalidX25519PrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::X25519PrivateKeyIsWrongLength => "TypeError",
+      AsymmetricPrivateKeyError::InvalidEd25519PrivateKey => "TypeError",
+      AsymmetricPrivateKeyError::MissingDhParameters => "TypeError",
+      AsymmetricPrivateKeyError::UnsupportedPrivateKeyOid => "TypeError",
+    }
+  }
+
+  pub fn get_asymmetric_public_key_error(
+    e: &AsymmetricPublicKeyError,
+  ) -> &'static str {
+    match e {
+      AsymmetricPublicKeyError::InvalidPemPrivateKeyInvalidUtf8(_) => {
+        "TypeError"
+      }
+      AsymmetricPublicKeyError::InvalidPemPublicKey => "TypeError",
+      AsymmetricPublicKeyError::InvalidPkcs1PublicKey => "TypeError",
+      AsymmetricPublicKeyError::AsymmetricPrivateKey(e) => {
+        get_asymmetric_private_key_error(e)
+      }
+      AsymmetricPublicKeyError::InvalidX509Certificate => "TypeError",
+      AsymmetricPublicKeyError::X509(_) => "Error",
+      AsymmetricPublicKeyError::X509PublicKey(e) => {
+        get_x509_public_key_error(e)
+      }
+      AsymmetricPublicKeyError::UnsupportedPemLabel(_) => "TypeError",
+      AsymmetricPublicKeyError::InvalidSpkiPublicKey => "TypeError",
+      AsymmetricPublicKeyError::UnsupportedKeyType(_) => "TypeError",
+      AsymmetricPublicKeyError::UnsupportedKeyFormat(_) => "TypeError",
+      AsymmetricPublicKeyError::Spki(_) => "Error",
+      AsymmetricPublicKeyError::Pkcs1(_) => "Error",
+      AsymmetricPublicKeyError::RsaPssParamsParse(_) => "TypeError",
+      AsymmetricPublicKeyError::MalformedDssPublicKey => "TypeError",
+      AsymmetricPublicKeyError::MalformedOrMissingNamedCurveInEcParameters => {
+        "TypeError"
+      }
+      AsymmetricPublicKeyError::MalformedOrMissingPublicKeyInEcSpki => {
+        "TypeError"
+      }
+      AsymmetricPublicKeyError::Ec(_) => "Error",
+      AsymmetricPublicKeyError::UnsupportedEcNamedCurve => "TypeError",
+      AsymmetricPublicKeyError::MalformedOrMissingPublicKeyInX25519Spki => {
+        "TypeError"
+      }
+      AsymmetricPublicKeyError::X25519PublicKeyIsTooShort => "TypeError",
+      AsymmetricPublicKeyError::InvalidEd25519PublicKey => "TypeError",
+      AsymmetricPublicKeyError::MissingDhParameters => "TypeError",
+      AsymmetricPublicKeyError::MalformedDhParameters => "TypeError",
+      AsymmetricPublicKeyError::MalformedOrMissingPublicKeyInDhSpki => {
+        "TypeError"
+      }
+      AsymmetricPublicKeyError::UnsupportedPrivateKeyOid => "TypeError",
+    }
+  }
+
+  pub fn get_private_encrypt_decrypt_error(
+    e: &PrivateEncryptDecryptError,
+  ) -> &'static str {
+    match e {
+      PrivateEncryptDecryptError::Pkcs8(_) => "Error",
+      PrivateEncryptDecryptError::Spki(_) => "Error",
+      PrivateEncryptDecryptError::Utf8(_) => "Error",
+      PrivateEncryptDecryptError::Rsa(_) => "Error",
+      PrivateEncryptDecryptError::UnknownPadding => "TypeError",
+    }
+  }
+
+  pub fn get_ecdh_encode_pub_key_error(e: &EcdhEncodePubKey) -> &'static str {
+    match e {
+      EcdhEncodePubKey::InvalidPublicKey => "TypeError",
+      EcdhEncodePubKey::UnsupportedCurve => "TypeError",
+      EcdhEncodePubKey::Sec1(_) => "Error",
+    }
+  }
+
+  pub fn get_diffie_hellman_error(_: &DiffieHellmanError) -> &'static str {
+    "TypeError"
+  }
+
+  pub fn get_sign_ed25519_error(_: &SignEd25519Error) -> &'static str {
+    "TypeError"
+  }
+
+  pub fn get_verify_ed25519_error(_: &VerifyEd25519Error) -> &'static str {
+    "TypeError"
+  }
+}
+
+fn get_os_error(error: &OsError) -> &'static str {
+  match error {
+    OsError::Permission(e) => get_permission_check_error_class(e),
+    OsError::InvalidUtf8(_) => "InvalidData",
+    OsError::EnvEmptyKey => "TypeError",
+    OsError::EnvInvalidKey(_) => "TypeError",
+    OsError::EnvInvalidValue(_) => "TypeError",
+    OsError::Io(e) => get_io_error_class(e),
+    OsError::Var(e) => get_env_var_error_class(e),
+  }
+}
+
+fn get_sync_fetch_error(error: &SyncFetchError) -> &'static str {
+  match error {
+    SyncFetchError::BlobUrlsNotSupportedInContext => "TypeError",
+    SyncFetchError::Io(e) => get_io_error_class(e),
+    SyncFetchError::InvalidScriptUrl => "TypeError",
+    SyncFetchError::InvalidStatusCode(_) => "TypeError",
+    SyncFetchError::ClassicScriptSchemeUnsupportedInWorkers(_) => "TypeError",
+    SyncFetchError::InvalidUri(_) => "Error",
+    SyncFetchError::InvalidMimeType(_) => "DOMExceptionNetworkError",
+    SyncFetchError::MissingMimeType => "DOMExceptionNetworkError",
+    SyncFetchError::Fetch(e) => get_fetch_error(e),
+    SyncFetchError::Join(_) => "Error",
+    SyncFetchError::Other(e) => get_error_class_name(e).unwrap_or("Error"),
+  }
+}
+
 pub fn get_error_class_name(e: &AnyError) -> Option<&'static str> {
   deno_core::error::get_custom_error_class(e)
-    .or_else(|| deno_webgpu::error::get_error_class_name(e))
-    .or_else(|| deno_web::get_error_class_name(e))
-    .or_else(|| deno_webstorage::get_not_supported_error_class_name(e))
-    .or_else(|| deno_websocket::get_network_error_class_name(e))
+    .or_else(|| {
+      e.downcast_ref::<ChildPermissionError>()
+        .map(get_child_permission_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<PermissionCheckError>()
+        .map(get_permission_check_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<PermissionError>()
+        .map(get_permission_error_class)
+    })
+    .or_else(|| e.downcast_ref::<FsError>().map(get_fs_error))
+    .or_else(|| {
+      e.downcast_ref::<node::BlocklistError>()
+        .map(node::get_blocklist_error)
+    })
+    .or_else(|| e.downcast_ref::<node::FsError>().map(node::get_fs_error))
+    .or_else(|| {
+      e.downcast_ref::<node::IdnaError>()
+        .map(node::get_idna_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::IpcJsonStreamError>()
+        .map(node::get_ipc_json_stream_error)
+    })
+    .or_else(|| e.downcast_ref::<node::IpcError>().map(node::get_ipc_error))
+    .or_else(|| {
+      e.downcast_ref::<node::WorkerThreadsFilenameError>()
+        .map(node::get_worker_threads_filename_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::RequireError>()
+        .map(node::get_require_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::Http2Error>()
+        .map(node::get_http2_error)
+    })
+    .or_else(|| e.downcast_ref::<node::OsError>().map(node::get_os_error))
+    .or_else(|| {
+      e.downcast_ref::<node::BrotliError>()
+        .map(node::get_brotli_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::ModeError>()
+        .map(node::get_mode_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::ZlibError>()
+        .map(node::get_zlib_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::CipherError>()
+        .map(node::get_crypto_cipher_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::CipherContextError>()
+        .map(node::get_crypto_cipher_context_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::DecipherError>()
+        .map(node::get_crypto_decipher_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::DecipherContextError>()
+        .map(node::get_crypto_decipher_context_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::X509Error>()
+        .map(node::get_x509_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::KeyObjectHandlePrehashedSignAndVerifyError>()
+        .map(node::get_crypto_key_object_handle_prehashed_sign_and_verify_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::HashError>()
+        .map(node::get_crypto_hash_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::AsymmetricPublicKeyJwkError>()
+        .map(node::get_asymmetric_public_key_jwk_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::GenerateRsaPssError>()
+        .map(node::get_generate_rsa_pss_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::AsymmetricPrivateKeyDerError>()
+        .map(node::get_asymmetric_private_key_der_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::AsymmetricPublicKeyDerError>()
+        .map(node::get_asymmetric_public_key_der_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::ExportPublicKeyPemError>()
+        .map(node::get_export_public_key_pem_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::ExportPrivateKeyPemError>()
+        .map(node::get_export_private_key_pem_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::RsaJwkError>()
+        .map(node::get_rsa_jwk_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::EcJwkError>()
+        .map(node::get_ec_jwk_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::EdRawError>()
+        .map(node::get_ed_raw_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::Pbkdf2Error>()
+        .map(node::get_pbkdf2_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::ScryptAsyncError>()
+        .map(node::get_scrypt_async_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::HkdfError>()
+        .map(node::get_hkdf_error_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::RsaPssParamsParseError>()
+        .map(node::get_rsa_pss_params_parse_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::AsymmetricPrivateKeyError>()
+        .map(node::get_asymmetric_private_key_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::AsymmetricPublicKeyError>()
+        .map(node::get_asymmetric_public_key_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::PrivateEncryptDecryptError>()
+        .map(node::get_private_encrypt_decrypt_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::EcdhEncodePubKey>()
+        .map(node::get_ecdh_encode_pub_key_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::DiffieHellmanError>()
+        .map(node::get_diffie_hellman_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::SignEd25519Error>()
+        .map(node::get_sign_ed25519_error)
+    })
+    .or_else(|| {
+      e.downcast_ref::<node::VerifyEd25519Error>()
+        .map(node::get_verify_ed25519_error)
+    })
+    .or_else(|| e.downcast_ref::<NApiError>().map(get_napi_error_class))
+    .or_else(|| e.downcast_ref::<WebError>().map(get_web_error_class))
+    .or_else(|| {
+      e.downcast_ref::<CreateWorkerError>()
+        .map(get_create_worker_error)
+    })
+    .or_else(|| e.downcast_ref::<TtyError>().map(get_tty_error))
+    .or_else(|| e.downcast_ref::<ReadlineError>().map(get_readline_error))
+    .or_else(|| e.downcast_ref::<SignalError>().map(get_signal_error))
+    .or_else(|| e.downcast_ref::<FsEventsError>().map(get_fs_events_error))
+    .or_else(|| e.downcast_ref::<HttpStartError>().map(get_http_start_error))
+    .or_else(|| e.downcast_ref::<ProcessError>().map(get_process_error))
+    .or_else(|| e.downcast_ref::<OsError>().map(get_os_error))
+    .or_else(|| e.downcast_ref::<SyncFetchError>().map(get_sync_fetch_error))
+    .or_else(|| {
+      e.downcast_ref::<CompressionError>()
+        .map(get_web_compression_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<MessagePortError>()
+        .map(get_web_message_port_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<StreamResourceError>()
+        .map(get_web_stream_resource_error_class)
+    })
+    .or_else(|| e.downcast_ref::<BlobError>().map(get_web_blob_error_class))
+    .or_else(|| e.downcast_ref::<IRError>().map(|_| "TypeError"))
+    .or_else(|| e.downcast_ref::<ReprError>().map(get_ffi_repr_error_class))
+    .or_else(|| e.downcast_ref::<HttpError>().map(get_http_error))
+    .or_else(|| e.downcast_ref::<HttpNextError>().map(get_http_next_error))
+    .or_else(|| {
+      e.downcast_ref::<WebSocketUpgradeError>()
+        .map(get_websocket_upgrade_error)
+    })
+    .or_else(|| e.downcast_ref::<FsOpsError>().map(get_fs_ops_error))
+    .or_else(|| {
+      e.downcast_ref::<DlfcnError>()
+        .map(get_ffi_dlfcn_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<StaticError>()
+        .map(get_ffi_static_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<CallbackError>()
+        .map(get_ffi_callback_error_class)
+    })
+    .or_else(|| e.downcast_ref::<CallError>().map(get_ffi_call_error_class))
     .or_else(|| e.downcast_ref::<TlsError>().map(get_tls_error_class))
     .or_else(|| e.downcast_ref::<CronError>().map(get_cron_error_class))
     .or_else(|| e.downcast_ref::<CanvasError>().map(get_canvas_error))
     .or_else(|| e.downcast_ref::<CacheError>().map(get_cache_error))
+    .or_else(|| e.downcast_ref::<WebsocketError>().map(get_websocket_error))
+    .or_else(|| {
+      e.downcast_ref::<HandshakeError>()
+        .map(get_websocket_handshake_error)
+    })
+    .or_else(|| e.downcast_ref::<KvError>().map(get_kv_error))
+    .or_else(|| e.downcast_ref::<FetchError>().map(get_fetch_error))
+    .or_else(|| {
+      e.downcast_ref::<HttpClientCreateError>()
+        .map(get_http_client_create_error)
+    })
+    .or_else(|| e.downcast_ref::<NetError>().map(get_net_error))
+    .or_else(|| {
+      e.downcast_ref::<deno_net::io::MapError>()
+        .map(get_net_map_error)
+    })
     .or_else(|| {
       e.downcast_ref::<BroadcastChannelError>()
         .map(get_broadcast_channel_error)
     })
     .or_else(|| {
+      e.downcast_ref::<deno_webgpu::InitError>()
+        .map(get_webgpu_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_webgpu::buffer::BufferError>()
+        .map(get_webgpu_buffer_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_webgpu::bundle::BundleError>()
+        .map(get_webgpu_bundle_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_webgpu::byow::ByowError>()
+        .map(get_webgpu_byow_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_webgpu::render_pass::RenderPassError>()
+        .map(get_webgpu_render_pass_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_webgpu::surface::SurfaceError>()
+        .map(get_webgpu_surface_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<DecryptError>()
+        .map(get_crypto_decrypt_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<EncryptError>()
+        .map(get_crypto_encrypt_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_crypto::SharedError>()
+        .map(get_crypto_shared_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_crypto::Ed25519Error>()
+        .map(get_crypto_ed25519_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<ExportKeyError>()
+        .map(get_crypto_export_key_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<GenerateKeyError>()
+        .map(get_crypto_generate_key_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<ImportKeyError>()
+        .map(get_crypto_import_key_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_crypto::X448Error>()
+        .map(get_crypto_x448_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_crypto::X25519Error>()
+        .map(get_crypto_x25519_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_crypto::Error>()
+        .map(get_crypto_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<WebStorageError>()
+        .map(get_webstorage_class_name)
+    })
+    .or_else(|| {
+      e.downcast_ref::<deno_url::UrlPatternError>()
+        .map(|_| "TypeError")
+    })
+    .or_else(|| {
       e.downcast_ref::<dlopen2::Error>()
         .map(get_dlopen_error_class)
     })