JSPM

richer JavaScript errors

Create an error with a code

Error wrapping utility for NodeJS and the browser

Format an error message for production.

Create an error from an array of error messages

Copy an error object.

Test if a value is an Error object.

Copy or deep clone a value to an arbitrary depth.

Returns a JSON representation of an error (handles nested errors and calls nested toJSONs)

Doesn't throw an error when JSON.parse() fails, just returns undefined

Easily generate "custom" error objects with addition properties which can be stringfied with JSON.stringify

Return a JSON representation of an error object.

richer JavaScript errors

callback wrapper

Parse errors in the Browser and Node. Made for Cabin.

Error factory with the ability to append stack traces from previous errors, as well as appending debug params to stack traces. Great if you want one appended stack trace that defines the error at many levels of your code. This concept works wonders when

A map of log level aliases matched to their numeric values. Follows the RFC Standard.

Errors.

Clean up error stack traces from node internals

Non-intrusively convert the result of any function or promise to the user's desired style.

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.

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

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

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

Rust-like Result for TypeScript

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

Avoid if(err)return bla bla bla

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

Rust-like Option for TypeScript

A Error middleware for express

A bare-metal Result type for Javascript/TypeScript

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.

Compute the root mean squared error (RMSE) incrementally.

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

Revives a JSON-serialized error object.

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 a moving mean error (ME) incrementally.

Compute the mean squared error (MSE) incrementally.

Rust-like APDU protocol for TypeScript

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

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

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

Result in TypeScript

Compute the residual sum of squares (RSS) incrementally.

Compute a moving mean absolute error (MAE) incrementally.

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

Compute the mean error (ME) incrementally.

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

Compute the mean percentage error (MPE) incrementally.

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

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

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.

Test if a value is a SyntaxError 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.

proptype validators for results instances

Makes easy to use HTTP status and errors.

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.

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

Create error instances with a code, status, etc.

richer JavaScript errors, but without sprintf

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) }'

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

get rid of `if (err) throw err`

common error defines as JSON format

Portable errors for Javascript

module for error handling in sailsjs, firts version

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.