isaacs

A deep deletion module for node (like `rm -rf`)

An evented streaming XML parser in JavaScript

Tap plugin that adds a heaping pile of assertion methods. Pretty much all of the "test" methods other than `t.pass`, `t.fail`, and [snapshot methods](https://tapjs.github.io/tapjs/modules/_tapjs_snapshot.html) come from this plugin.

TypeScript HYbridizer - Hybrid (CommonJS/ESM) TypeScript node package builder

create a pipeline of streams using Minipass

minimal implementation of a PassThrough stream

easily create complex multi-column command-line-interfaces

tar for node

Quick and dirty signatures for Objects.

Virtual Environments for Node

When a root node matches a metadep being added to the tree, the loop-detection link deduplication made in a lot of problems as a result of the link going to the root node from the /virtual-tree temp tree, ultimately resulting in the root node being reifie

Put a bunch of emitted events in an array, for testing.

Captures and cleans stack traces

PrismJS syntax highlighting for the terminal

when you want to fire an event no matter how a process exits.

a glob matcher in javascript

Browser-friendly inheritance fully compatible with standard node.js inherits()

A drop-in replacement for fs, making various improvements.

walk paths fast and efficiently

Recursively mkdir, like `mkdir -p`

like `chown -R`

Load the local package.json from either src or dist folder

like touch(1) in node

A very strict and proper argument parser.

Minimal module to check if a file is executable.

A module which will endeavor to guess your terminal's level of color support.

A small fast zlib stream built on [minipass](http://npm.im/minipass) and Node.js's zlib binding.

A thing that is a lot like ES6 `Map`, but without iterators, for use in environments where `for..of` syntax and `Map` are not available.

The `util.is*` functions introduced in Node v0.12.

A Minipass stream that raises an error if you get a different number of bytes than expected

Run operations on a graph, maximizing parallelism

Put a little spinner on process.stderr, as unobtrusively as possible.

HANDLE CONFIGURATION ONCE AND FOR ALL

JSON.parse and stringify with better errors that respects formatting

A Minipass stream that collects all the data into a single chunk

An implementation of Domain-like error handling, built on async_hooks

Take a big diff with a 2-line header and turn it into frags with only a reasonable amount of context

Yet Another object pool in JavaScript

Compare strings with Intl.Collator if available, falling back to String.localeCompare otherwise

Call an array of promise-returning functions, restricting concurrency to a specified limit.

Infer the owner of a path based on the owner of its nearest existing parent

Find the common ancestor of 2 or more paths on Windows or Unix

Brace expansion as known from sh/bash

A program for parsing CouchDB logs

the command line bin script that used to be in node-glob

Run a function exactly one time

Use node's fs.realpath, but fall back to the JS implementation if the native one fails

A Minipass stream that calls a flush function before emitting 'end'

The most dead-simple trivial Deferred implementation

Yet Another Linked List

Like Promise.all, but save rejections until all promises are resolved

A little utility for doing side-by-side benchmarks in nodejs

Enable destroying a server, and all currently open connections.

Node's internal object extension function

Like JSON.stringify, but doesn't blow up on circular refs.

A very polite lock file utility, which endeavors to not litter, and to wait patiently for others.

Run a list of functions in order in a given object context. The functions can be callback-taking or promise-returning.

Verify if something is a Promise

This module exists to facilitate the `t.match()` method in [`tap`](http://npm.im/tap).

A wrapper that chooses http or https for requests

the logic behind tap's t.same() and t.strictSame()

Parse a url assuming `http` if no protocol or `//` is provided.

the most correct and second fastest glob implementation in JavaScript

Like which(1) unix command. Find the first instance of an executable in the PATH.

Get the best guess as to what url the user actually requested, based on what the `Forwarded`, `X-Forwarded-*`, `X-Forwarded-For`, ..., request headers are trying to tell you.

A fast linked list (good for queues, stacks, etc.)

A flow control lib small enough to fit on in a slide presentation. Derived live at Oak.JS

mkdirp, but chown to the owner of the containing folder if possible and necessary

Just like `fs.exists` and `fs.existsSync`, but cached

A cache object that deletes the least-recently-used items.

a mock clock for tests involving timing

Mutate the filesystem behavior for tests.

Given a path string, return a generator that walks up the path, emitting each dirname.

A utility for creating a daemon process that listens on a socket, and a client that talks to it.

Look up the file that an `import()` statement will resolve to, possibly relative to a given parentURL

Like JSONStream, but using Minipass streams

Clean up an object prior to serialization

Parser/encoder for the yamlish format

A utility for managing a prototype chain

Either use the object's own property, or a fallback

Use an objects own property, or an environment variable. Optionally treat as a boolean if the env should be set to 1 or 0.

Convert a NODE_OPTIONS environment variable to an argv list, or vice versa

The time-based use-recency-unaware cousin of [`lru-cache`](http://npm.im/lru-cache)

Cache a function that takes a path as an argument, expiring whenever the file mtime changes

convert string with ANSI color codes into a styled html pre tag

Makes all modules in Node get loaded in strict mode.

SDK for using https://tier.run in Node.js applications

Match balanced character pairs, like "{" and "}"

Format a TAP stream using Mocha's set of reporters