JSPM

Clean up error stack traces from node internals

Standard library error code database.

Thorw error objects directly from express response

use global AggregateError or from core-js-pure

redirect console methods to streams

Return a two-character error identifier corresponding to a provided error message.

VError without dependencies on top of nodejs standart library

Returns a JSON representation of an error object.

TypeScript goodies inspired by Rust.

Yet another extensible error library for node.js

Err module.

Modify given `err` object to be more useful - adds `at`, `line`, `column`, `place` and `filename` properties and also cleans stack traces.

Handle completion and errors with elegance! Support for streams, callbacks, promises, child processes, async/await and sync functions. A drop-in replacement for [async-done][] - pass 100% of its tests plus more

Finds the correct place where the stack trace was started, not the place where error was thrown

Automatically transform Mongoose validation error message(s) to a humanized and readable format

Handling/creating hybrid errors. Hybrid middleware between callbacks and throws. Helpful util for modules that have hybrid APIs and want when they use promises, directly to throw the errors; when use callbacks to pass errors to first argument of this call

Rust-like Result for TypeScript

Avoid if(err)return bla bla bla

A production-grade error creation and serialization library designed for Typescript

Rust-like Option for TypeScript

A bare-metal Result type for Javascript/TypeScript

A Error middleware for express

Rust-like results in TypeScript

Wrapper around the assert module

send an error notifications

Easily ignore specific promise errors

error reporting for js

An easy way to make an error in Node.js async, when it would sync otherwise.

Compute the mean absolute percentage error (MAPE) incrementally.

Rust-like KeePass (KDBX 4) file format for TypeScript

Revives a JSON-serialized error object.

Compute the root mean squared error (RMSE) incrementally.

Compute a moving mean squared error (MSE) incrementally.

A less-instrusive way of passing errors along in JavaScript / NodeJS.

Compute the mean absolute error (MAE) incrementally.

Compute the mean squared error (MSE) incrementally.

Compute a moving mean error (ME) incrementally.

Compute a moving root mean squared error (RMSE) incrementally.

Rust-like APDU protocol for TypeScript

Compute a moving residual sum of squares (RSS) incrementally.

Result in TypeScript

Compute a moving mean absolute percentage error (MAPE) incrementally.

Compute a moving mean absolute error (MAE) incrementally.

Compute the mean error (ME) incrementally.

Compute the mean arctangent absolute percentage error (MAAPE) incrementally.

Compute the residual sum of squares (RSS) incrementally.

Compute a moving arctangent mean absolute percentage error (MAAPE) incrementally.

Check native type of value and throw AssertionError if not okey. Clean stack traces. Simplicity. Built on [is-kindof][].

Compute the mean percentage error (MPE) incrementally.

Compute a moving mean percentage error (MPE) incrementally.

Set Error cause

strips chromium logs from a stream

Promisify sync, async or generator function, using [relike][]. Kind of promisify, but lower level. Full compatibility with [co][]4 and passing 100% of its tests.

Additional functionality to [kind-of][] type check utility. Support promises, generators, streams, errors.

Test if a value is a TypeError object.

Extract error message from an object using known error properties.

Return an error message corresponding to a provided two-character error identifier.

Rust-like JSON-RPC for TypeScript

Return a function which formats an error message for production.

Simple error message formatting.

Relative error exponential.

Generate heap dumps and detailed output for uncaught exceptions and critical errors

Test if a value is a RangeError object.

Secure and private reimplementation of the WalletConnect protocol

A simple module to make showing users an error easier

Test if a value is a SyntaxError object.

resulta is a TypeScript utility for handling results in an expressive way, inspired by Rust's Result type.

Generic Error Handler

Test if a value is a ReferenceError object.

Generic middleware based on (err, next, ...args) pattern.

Custom JavaScript errors

Better error handling in TypeScript.

Generic middleware based on (next, err, ...args) pattern.

A lightweight functional library for functional composition and object composition.

This is a utility package to handle errors and unwanted results automatically. It is used to improve readability of code and simplify working with callbacks.

create error instances with a code (and props)

rust like result class

Create an iterator which evaluates the relative error exponential for each iterated value.

Error handling and extras for `.use` and `.run` methods of your Base apps. Modifies `.use` method to be able to 1) accept array of functions, 2) options object as second argument. Emits `error` event if some plugin fails.

proptype validators for results instances

Makes easy to use HTTP status and errors.

Converts result-first callbacks to classic (node.js-style) error-first callbacks with 3 lines of code. Useful when you want to promisify result-first APIs (like emitter.on). Inspired by [rfpify][] and probably used in it.

generates a string containing a message and trimmed stack from error

richer JavaScript errors, but without sprintf

Create error instances with a code, status, etc.

Allows you to customize the toString method of passed `err`. Also adds useful properties like `line`, `filename` and `column` to the `err` object.

tape error events for t.fail(msg)

Not so strongly typed error

A TypeScript library implementing Rust-like error handling with Result, Ok, and Err types.

Displays http status in browser, good for error handling.

Easily create an error with custom properties attached.

Collection of error handling utilities for JavaScript and TypeScript.

Extra err.stack entries for debuggability. Better than your plain 'if (err) { return cb(err) }'

common error defines as JSON format

Graceful error handling. Because core `domain` module is deprecated. This share almost the same API.

get rid of `if (err) throw err`

module for error handling in sailsjs, firts version

Portable errors for Javascript

For those who don't like the node (er, result) convention

Clean up error stack traces

一个用于node环境的Error子类，提供更丰富的构造参数接口，更友好的code-frame提示，消息拼接等功能，详见Sample截图

errors with clean stacks

Test if a value is a URIError object.

Result type

ThrowAndTell Error Reporter Client for Node.js

This is a small lib to help create and manage log files

module for error handling in sailsjs, firts version

A lightweight set of error utilities for node.js

This module logs errors that you give it to log.

test err handler

<h1 align="center">Neverthrow-Pattern</h1>

A callback factory which splits away handling errors into a separate flow and thus requiring less boilerplate code.

Function to get JSON friendly object from error (Node/V8 only).

A callback wrapper library that reduces the number of checks needed to propagate errors up the callback chain

Revive a JSON-serialized error object.

strips Electron/Chromium logs from stderr

Return a two-character error identifier corresponding to a provided error message.

handle callback err with node style

verror that also works for browsers and react-native

a javascript library to log errors

Result in TypeScript

Return an error message corresponding to a provided two-character error identifier.

A version of Rust's result type in Typescript, which can be Ok or Err (oker)

Require module but with error handeling

提供了响应错误信息的中间件

Test if a value is an EvalError object.