JSPM

Get callsites from the V8 stack trace API

Get the path of the parent module

Elegant Console Wrapper

return list of CallSite objects from a captured stacktrace

Extract meaning from JS Errors

JS Object representation of a stack frame

Framework-agnostic, micro-library for getting stack traces in all environments

Parses every stack trace into a nicely formatted array of hashes.

Get the callsite of the caller function

Get the path of the caller function

Generate artificial backtrace by walking arguments.callee.caller chain

Turns partial code location into precise code location

Parses call stacks. Reads sources. Clean & filtered output. Sourcemaps. Node & browsers.

Extract meaning from JS Errors

The official Elastic APM agent for Node.js

Extract callsite objects from Error objects

Extensible TypeScript Logger for Node.js and Browser.

A Babel plugin which automatically makes stack traces source-map aware

Normalize exceptions/errors

A native Node.js module that can capture JavaScript stack traces from main and worker threads, even with blocked event loops.

Properly update an error's message

Axios plugin that provides better stack traces for axios errors

Error wrapping in Node.js

Reads a source file and extracts a sourcemap for consumption (inline or external)

Much better tracing of unhandled promise rejections in JavaScript

Enhance an error stacktrace with code excerpts and other goodies

Merge an error with its inner cause

Properly wrap an error's message

📞 Get the location from where you're called from.

Properly create error classes

Handle errors in a simple, stable, consistent way

Create custom error classes

Logging. Colors. Terminals & browsers. Show call locations. Pretty prints objects, Errors, anything!

Convert errors to/from plain objects

Properly update an error's stack

Get stack info for a position in code.

`modern-errors` plugin to create HTTP error responses

Atatus APM agent for Node.js

Create HTTP error responses

long stack traces for node.js

Define errors without frills, but with stack traces and instanceof support.

`modern-errors` plugin to handle errors in CLI modules

Ayamari helps you to create rich errors in a simple and consistent way.

UMD __dirname and __filename browser shim

Fork of error-stack-parser with some not-yet-released changes

Error with more than just a message, stacktrace parsing.

`modern-errors` plugin to clean stack traces

Pinpoint node agent provided by NAVER

An array of node internals that can be cleaned up from stack traces

Easy access to the call stack, written in pure JavaScript

CoffeeScript stack trace converter

A library that fixes all your stack trace problems.

Tool for decrypting stack traces coming from the minified JS code

Polyfill `error.cause`

A lean, zero dependency library to provide a useful base for your project.

Provides readable mapped stacktrace for failed tests to debug the them in your browser.

Meant to be used with [clean-stacktrace][] as mapper function. Makes absolute paths inside stack traces to relative paths.

My friendly error base class - for Node/JavaScript.

A simple and easy JavaScript library for highlighting .NET stack traces

Displays JS errors in browsers. Shows sources. Opens locations in VS Code. Framework agnostic.

A library to retrieve the source location of DOM elements in React applications

Make a color-coded stack trace from an error

Error handlers for use in development and production environments.

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

Gets an object containing normalized stacktrace information across browsers.

a wrapper around the `node` executable for better stacktraces with sourcemaps, sourcecode excerpts

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

Plugin for `clean-stacktrace` lib. Parse each line to get additional info like `filename`, `column` and `line` of the error.

@reliverse/relinka is a modern, minimal logging library that actually feels right. It's not just pretty output — it's a system: smart formatting, file-safe logging, runtime config support, and a fatal mode built for developers who care about correctness.

Magical Console Wrapper with Conventional💙Commits

Standard Error Library for JavaScript/TypeScript projects (NodeJS & Browsers)

A general base Error class that can be extended to create custom Error classes

`modern-errors` plugin to prettify errors.

Stacktrace parser for NodeJS written in Typescript with getting the code in which the error occurs.

Efficient lightweight logger

humanized stack traces for the error class

Get the current stack trace as an array (V8 only).

Better usage for axios

📝 Extensible TypeScript Logger for Node.js and Browser: Dependency free, Fully customizable, Pretty errors, stack traces, and JSON output to attachable transports.

Ono is an error-parsing library that pretty prints JavaScript errors on a web page or the terminal.

✨ A modern, colorful, and developer-friendly logger for Node.js — featuring i18n, smart stack traces, and CLI formatting helpers.

A handy library for creating custom error constructors that work across async boundaries in Node.js.

JS Object representation of a stack frame

parse stacktrace with sourcemap

App utility functions by Harald Rudell

When code dies, it deserves a proper autopsy. Stacktrace library with sourcemap support.

📝 Expressive TypeScript Logger for Node.js: Pretty errors, stack traces, code frames, and JSON output to attachable transports.

Emit and/or format raw stacktraces when errors are thrown

Whoops error handler for Node.js / Express — Whoops+ theme with inline regex syntax highlighting

The simplest possible callstack fetcher

Track and visualize async objects created in your application with ease

A Babel6 verion fork.A Babel plugin which automatically makes stack traces source-map aware

Pinpoint node agent provided by NAVER (Personalized version)

The unofficial Opbeat client for Ionic

A Babel 6 plugin that automatically makes stack traces sourcemap aware. Requires V8.

Deep stack traces plus active handles with cheese.

The Elastic APM agent for Node.js with ability to read raw metrics.

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

Debugging helpers.

The official Atatus agent for Node.js

A simple js package to analyze java exception stacktrace

log with colors, show debug log when envVar VERBOSE is set, show stacktrace, also log with date info

Stacktraces for compiled/minified scripts

Turn JavaScript stack traces into structured data.

Get v8 stack traces as a detailed array of CallSite objects.

Translate stacktraces from minified JS to readable format

Easy logging for node.js, with automatic file/line output

A lightweight toolkit to create and manage expressive, structured, and reusable error types. Perfect for APIs, services, and glitchy adventures

Pops frames off of your stack traces!

Unminify stacktraces with a souce map.

Friendly fork of stacktracey to fix bugs.

Extensible TypeScript Logger for Node.js and Browser.

Show rich stacktraces in express application

The Elastic APM agent for Metoer.js framework

A pocket-sized debugging dino that pecks away at every error and shows you exactly what went wrong and where—no more hunting through messy stack traces.

Better stacktraces. Colors! Long stacktraces! File contents!

Maps JavaScript stack traces back to source using sourcemaps both in browsers and Node.

Log everything, everywhere

catch errors of asynchronous functions with prior stacktrace

Express middleware to (automatically) render content and errors to content-type

> Parse, filter, and format JavaScript stack traces with plugins for browsers and Node.js.

JS Object representation of a stack frame

Library for getting stack traces in cross browser manner.

Browser based error reporting client for Stackbin

Unminify stacktraces with a souce map.

Debug your code, not the Runtime

Get the path of the caller function

Better Nodejs error is a small nodejs package to render errors in a better way to make it easy for you to identify errors and fix it fast.

Based of the official Elastic APM agent for Node.js v2.11.6

A CLI tool to map stack traces to source code.

Adds JavaScript symbols to lldb stack traces

A small tool for beautifying dev texts (stack traces, log outputs, JSONs)

Get the callsite of the caller function

Small script that takes a JS stack trace from a generated script and makes it point to the original source

Decorate callsites with methods that return the sourcemapped file/line/column locations

boils down `require( 'clarify' ); require( 'trace' ); Error.stackTraceLimit = Infinity` into `require( 'guy-trace' )`

Gets the caller function, file and line number in all browsers and server environments

Stop losing stack trace on Node event loop callbacks

Parses every stack trace into a nicely formatted array of hashes.

Extract meaning from JS Errors

Examine the calling code.

Process errors and normalize the output

React component for presenting exceptions in the browser

The official Elastic APM agent for Node.js

JS Object representation of a stack frame

Unminify stacktraces with a souce map.

Provied a single callback that runs when browser throws any uncaught exception

Angular's `ErrorHandler` implementation for development environment

stackframes

Wraps calls in named function to have context in stacktrace

Extensible TypeScript Logger for Node.js and Browser.

Long stack traces for Promise (Node 8 only)

Easy access to the call stack, written in pure JavaScript

Uncaught exception logging with stack traces for Backbone apps

A utility for managing logs and debug process node.js

The official Elastic APM agent for Node.js

Converts a stacktrace using a sourcemap.

Modern Java stack traces viewer for Angular

Adds a console.label() function that acts like console.log, except it automatically adds a label to each log with the name of the variable being logged

Parse Java stack traces and transform them into comprehensive JS objects

A minimalistic library that shows the caller's location in log messages, with an optional timestamp, log level.

color coded console output and stack traces

Core library for Debugmate, providing essential utilities for debugging tools and plugins.

this.debugging = debug + callsites + derived namespacing

Stack traces for ember js apps.

Makes error handling beautiful in express

costack gives you full stacktrace errors on promise based apps

Long stack traces for node.js

The (un)official multiagent Opbeat agent for Node.js. Built over the official one

Behance Karma Stacktrace Transforms

Extensible TypeScript Logger for Node.js and Browser.

simpler stacktraces

Quickly and easily NodeJS module for save and report any logs.

Simple error handling component for React v.16

The unofficial Elastic APM agent for Node.js 15

Symbolicate JavaScript stack traces using source maps. Supports Chrome, Safari, and Firefox stack traces.

代码回溯。指定文本的位置，格式化显示选定区域

Wrappers around established stack-parsing libraries

The official zuQA APM agent for Node.js

A function Call stack in node.js using JavaScriptStackTrace Api

Converts a stacktrace using a sourcemap.

Watches and logs V8 events using the internal programmatic debugger

Minimal, powerful, and highly customizable error parser and manager for JavaScript! 🚀

Extract meaning from JS Errors

Long stack traces for Promise (Node 8 only). Forked from long-promise.

Multi-level JS browser logger with accurate stack traces

logging made easy, useful and scalable

Extract meaning from JS Errors

Turns partial code location into precise code location

Catch all JavaScript errors and post them to your server

Useful error stacks for development that include code highlighting.

Command-line interface to the [`source-map`](https://github.com/mozilla/source-map) module.

The official Elastic APM agent for Node.js

Simple logging library for Node.js and Browser

Get the file path of the caller function

The unofficial Elastic APM agent for Node.js and Tedious driver

A simple and typed parser to extract meaningful data from NestJS-style stack traces.

Multi-level JS browser logger with accurate stack traces

A super simple ES6 class factory for extending Error

A lightweight nodemon-like CLI that shortens stack traces and restarts Node apps on file changes.