isaacs

the most correct and second fastest glob implementation in JavaScript

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

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

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

a glob matcher 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.

Virtual Environments for Node

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

An evented streaming XML parser in JavaScript

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

tar for node

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

A module for serving static files. Does etags, caching, etc.

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

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

minimal implementation of a PassThrough stream

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

Run a function exactly one time

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

Yet Another Linked List

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

Captures and cleans stack traces

Recursively mkdir, like `mkdir -p`

Enable destroying a server, and all currently open connections.

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

like touch(1) in node

HANDLE CONFIGURATION ONCE AND FOR ALL

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

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

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

Quick and dirty signatures for Objects.

A very strict and proper argument parser.

Minimal module to check if a file is executable.

walk paths fast and efficiently

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

Makes all modules in Node get loaded in strict mode.

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

like `chown -R`

Node's internal object extension function

Format a TAP stream using Mocha's set of reporters

JSON.parse and stringify with better errors that respects formatting

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

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

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

Parser/encoder for the yamlish format

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

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.

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

Run operations on a graph, maximizing parallelism

Mutate the filesystem behavior for tests.

A utility for managing a prototype chain

A wrapper that chooses http or https for requests

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

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

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

A program for parsing CouchDB logs

a mock clock for tests involving timing

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

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

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

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

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

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

PrismJS syntax highlighting for the terminal

Yet Another object pool in JavaScript

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

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

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

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

create a pipeline of streams using Minipass

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

Verify if something is a Promise

Like JSONStream, but using Minipass streams

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

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

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

Clean up an object prior to serialization

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

easily create complex multi-column command-line-interfaces

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

The most dead-simple trivial Deferred implementation

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

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

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

An evented streaming XML parser in JavaScript

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

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

Brace expansion as known from sh/bash

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

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 utility for creating a daemon process that listens on a socket, and a client that talks to it.

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

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

A Test-Anything-Protocol library for JavaScript

RED/USE metrics for express applications (forked to remove vulnerable optional deps)

A default tap plugin that adds snapshot functionality.

Stream TAP test data as a serialized node:test stream

parse the test anything protocol

A comprehensive comparison library, for use in test frameworks

the pluggable Test class for node-tap

a built-in tap extension for t.worker()

TypeScript execution environment and REPL for node.js, with source map support

tap plugin adding t.mockRequire() and t.mockImport()

a built-in tap extension for t.intercept() and t.capture()

a make believe clock for tests involving time

Tap plugin to provide t.testdir() and t.fixture()

Yaml handling for TAP parsers and generators

Utility loading and managing tap configuration

Command-line interface for the node-tap runner