A module which will endeavor to guess your terminal's level of color support.
Log all the node processes that get spawned
WHEN I WROTE the following pages, or rather the bulk of them, I lived alone, in the woods, a mile from any neighbor, in a house which I had built myself, on the shore of Walden Pond, in Concord, Massachusetts, and earned my living by the labor of my hands
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.
Bind methods to an object from that object or some other source. Optionally specify a set of methods to skip over.
Yet Another object pool in JavaScript
Run a list of functions in order in a given object context. The functions can be callback-taking or promise-returning.
The most dead-simple trivial Deferred implementation
Just like `fs.exists` and `fs.existsSync`, but cached
A locking socket alternative to file-system mutex locks
A [fs.ReadStream](https://nodejs.org/api/fs.html#fs_class_fs_readstream) that supports seeking to arbtrary locations within a file.
Just proving my npm account for keybase
Mutate the filesystem behavior for tests.
the logic behind tap's t.same() and t.strictSame()
this will be gone soon, don't get attached
Self-organizing dnode network
A test framework for running TAP test
A default harness for running TAP test
A util for keeping track of tap result objects
A harness for TAP Tests to use
A module for producing TAP output
A module for running all the tests in a directory
An assertion module that returns TAP result objects
A module for consuming TAP output
A call-and-response message passing system for node's cluster builtin
A demo blog written live at Voxer HQ so it probably isn't great.
A filter stream to pull out the questions from an irssi log file
Redirect users to the canonical hostname for your site.
The port of Showdown used on github.com
A program for parsing CouchDB logs
Put a little spinner on process.stderr, as unobtrusively as possible.
A utility for managing a prototype chain
A website that serves the docs of npm packages.
A cookie middleware for tako
csrf protection for framework-less node sites
A very simple json-header-and-body protocol
Enable destroying a server, and all currently open connections.
Prevent *Sync functions from being run after the first tick
Wrap a 0.8 stream into a streams2 stream
Make your Node programs strict about stuff
Decrypt encrypted ssh private keys
Transform stream that truncates
an itty bitty curry utility
Pipe one stream in, many streams out. Goes as slow as the slowest writer.
like a passthrough, but in both directions
Turn stuff like `isaacs/npm#1234` into `https://github.com/isaacs/npm/issues/1234`, for your hyperlinking pleasure.
The correct name for Node.js's `net` module.
Duplex API for making an HTTP request (write the req, read the response)
A module for doing logged-in requests to a couchdb server
Easy way to create a client for Manta Node programs
Gather up a JSON response from a server, and call the cb
A wrapper that chooses http or https for requests
The `util.is*` functions introduced in Node v0.12.
Trim the `readme` fields on npm registry document objects.
Syslog proxy that receives syslogs from Fastly, and sends them to Logly.
A simple lowlevel synchronizing library for Joyent Manta.
A bridge between the M and C bits of MVC
A simple agent for performing a sequence of http requests in node.js
Core Service framework for Tesla
Put your CouchDB in Manta, attachments and docs and all
A service to keep a read-only CouchDB replica up to date
I am checking and creating npm's cache dir
Make an https server that is more resistant to client-initiated renegotiations, and other common security mistakes.
Asynchronous, non-blocking SQLite3 bindings
parse the test anything protocol
Easily send errors in Node.js HTTP servers. Think like the `ErrorDocument` declarations in Apache config files.
Make a registry with all attachments intact
The npmjs.org registry couchapp
Super simple HTTP server that can be easily pinged so that Nagios et al can know your stuff's healthy.
Yet another redis session thing for node
A fast linked list (good for queues, stacks, etc.)
A helper script for managing a cluster of node worker servers
A little utility for doing side-by-side benchmarks in nodejs
A module for attaching domains to request and response objects
HANDLE CONFIGURATION ONCE AND FOR ALL
A very polite lock file utility, which endeavors to not litter, and to wait patiently for others.
Quick and dirty signatures for Objects.
Callback wrapping utility
Parser/encoder for the yamlish format
A gyp file reader for node
Node's internal object extension function
A client for doing FS operations in multiple places in sync.
Move attachments into Manta and out of the registry
The config module for npm circa npm@1 and npm@2
A gist cli client written in Node
Makes all modules in Node get loaded in strict mode.
Drop in assert replacement that produces TAP output.
Cache your async lookups and don't fetch the same thing more than necessary.
An evented streaming XML parser in JavaScript
A lightweight template thing
Brace expansion as known from sh/bash
A drop-in replacement for JSON.parse that uses `jju` to give helpful errors
convert umask from string <-> number
Virtual Environments for Node
Parse a url assuming `http` if no protocol or `//` is provided.
a glob matcher in javascript
a thing to watch a file and then run a command
A drop-in replacement for fs, making various improvements.
Makes `process.exit` a deprecated no-op.
srand bindings for node - Seedable predictable pseudorandom number generator
A cache object that deletes the least-recently-used items.
Convert shorthand OSS license names to opensource.org URLs
The correct name for Node.js's `dgram` module.
A module for serving static files. Does etags, caching, etc.
A supervisor program for running nodejs programs
Browser-friendly inheritance fully compatible with standard node.js inherits()
Like JSON.stringify, but doesn't blow up on circular refs.
the most correct and second fastest glob implementation in JavaScript
A deep deletion module for node (like `rm -rf`)
Run a function exactly one time
A module to teach you how to module.
A Test-Anything-Protocol library for JavaScript
Search for a given string in specified files.
Put a bunch of emitted events in an array, for testing.
A sample scoped public package
`process.exitCode` behavior back-ported from io.js and Node.js 0.12+
Format a TAP stream using Mocha's set of reporters
A client for npm's internal acl service, and maybe eventually api.npmjs.com
Wrap all spawned Node.js child processes by adding environs and arguments ahead of the main JavaScript file argument.
the Istanbul command line interface
Run a child as if it's the foreground process. Give it stdio. Exit when it exits.
when you want to fire an event no matter how a process exits.
Given a name, make a unique name even on case-folding filesystems.
A collection of short (5 words or so) tips and tricks that can be sprinkled about the npm site.
This module exists to facilitate the `t.match()` method in [`tap`](http://npm.im/tap).
Kwalitee scoring for npm packages, providing tooling to help package authors
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.
Captures and cleans stack traces
The blobs of marketing goodness that go in the sidebar of https://www.npmjs.com/
Minimal module to check if a file is executable.
Turn any tap Test object into a promise-resolving thingie
Tee up a test server in one file, tear it down in another
build, concatenate, and compress assets
Use node's fs.realpath, but fall back to the JS implementation if the native one fails
a tiny module for piping an input to multiple output streams
A gatsby plugin to do tumble blog style media embeds, like photosets, videos, and links.
A very strict and proper argument parser.
Yaml handling for TAP parsers and generators
A comprehensive comparison library, for use in test frameworks
An implementation of Domain-like error handling, built on async_hooks
A utility for managing the `processinfo` folder that NYC uses.
An npm init module to create modules like I do
this is an example that auto-publishes on npm version
an empty thing to test namespaced package behavior
Recursively mkdir, like `mkdir -p`
Infer the owner of a path based on the owner of its nearest existing parent
create a pipeline of streams using Minipass
A Minipass stream that collects all the data into a single chunk
A Minipass stream that calls a flush function before emitting 'end'
A Minipass stream that raises an error if you get a different number of bytes than expected
Like JSONStream, but using Minipass streams
Stringify an object sorting scalars before objects, and defaulting to 2-space indent
Take a big diff with a 2-line header and turn it into frags with only a reasonable amount of context
has a peer dep on b, which has a peer dep on c
depends on a v2, which has a peer dep on b v2, which has a peer dep on c
depends on b, which has a peer dep on c, and d, which has a regular dep on a, which has a peer dep on b which has a peer dep on c
not part of the bundle party, but depends on b
a -> b -> c -> a. Can we upgrade a?
a -> b -> c -> a. Can we upgrade a?
a -> b -> c -> a. Can we upgrade a?
a -> b -> c -> a. Can we upgrade a?
Like Promise.all, but save rejections until all promises are resolved
depends on a module that has bundled deps
A Test-Anything-Protocol library for JavaScript
a package with an optional dependency on a package that does not exist
a package with an optional dependency on a package whose tarball does not exist
a package with an optional dependency on a package whose tarball does not exist
a package with an prod dependency on a package that does not exist
a production dep that is not satisfiable
an optional dep that is not satisfiable
a prod dependency that fails to install
mkdirp, but chown to the owner of the containing folder if possible and necessary
Call an array of promise-returning functions, restricting concurrency to a specified limit.
a prod dependency that fails to install
a prod dependency that fails to install
a prod dependency that fails to install
a package for testing dev, optional, and devOptional flags
depends on a vulnerable version of minimist, via a git reference
meta-depends on a vulnerable version of minimist, via a git reference
Protect promise-returning functions from being called more than once in parallel.
This is an example case showing that a `yarn.lock` file does not guarantee package resolutions at all levels.
- `root` depends on `parent` - `parent` bundles `a` - `a` depends on `b` - `b` has a build script
Given a path string, return a generator that walks up the path, emitting each dirname.
Find the common ancestor of 2 or more paths on Windows or Unix
``` a@1 -> b@1 a@2 -> b@2 b@1 -> a@2 b@2 -> a@1 ```
``` a@1 -> b@1 a@2 -> b@2 b@1 -> a@2 b@2 -> a@1 ```
Fizz Buzz but without using the % operator
debugging https://github.com/npm/cli/issues/1597
debugging https://github.com/npm/cli/issues/1597
debugging https://github.com/npm/cli/issues/1597
debugging https://github.com/npm/cli/issues/1597
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
A chain of peer deps. Installing v1 of any of them requires v1 of all of them. v2 of any requires v2 of all. No v1 can coexist with any v2.
a peer dep that is overridden by the root dependency
a peer dep that is overridden by the root dependency
just another testing thingie
Clean up an object prior to serialization
Just a way to keep calling a function as long as it's throwing, for some period of time.
``` root -> (x, y@1) x -> PEEROPTIONAL(z) z -> PEER(y@2) ```
``` root -> (x) PEEROPTIONAL(y@1) x -> PEEROPTIONAL(y@2) ```
``` root -> (x) PEEROPTIONAL(y@1) x -> PEER(z) z -> PEEROPTIONAL(y@2) ```
``` root -> (x, z@1) x -> PEEROPTIONAL(y) y -> PEER(z@2) ```
``` root -> (x, z@1) x -> PEEROPTIONAL(y) PEER(z@1) y -> PEER(z@2) ```
``` root -> (x, z@1) x -> PEEROPTIONAL(y) PEER(z@1) PEER(w@1) w -> PEER(z@1) y -> PEER(z@2) ```
``` a@1 -> b@1 a@2 -> b@2 ```
``` a@1 -> b@1 a@2 -> b@2 ```
Example of how to find actual location of the bin in a npm package if the bin is a bash script.
Compare strings with Intl.Collator if available, falling back to String.localeCompare otherwise
Require and transpile JSX on the fly (fork of import-jsx for node 17 support)
deprecated: use 'npm install tier' instead
This package includes the pre-compiled tier binary, and an index.js which reports the full path to the compiled binary.
This package includes the pre-compiled tier binary, and an index.js which reports the full path to the compiled binary.
This package includes the pre-compiled tier binary, and an index.js which reports the full path to the compiled binary.
This package includes the pre-compiled tier binary, and an index.js which reports the full path to the compiled binary.
This package includes the pre-compiled tier binary, and an index.js which reports the full path to the compiled binary.
This package includes the pre-compiled tier binary, and an index.js which reports the full path to the compiled binary.
a mock clock for tests involving timing
The time-based use-recency-unaware cousin of [`lru-cache`](http://npm.im/lru-cache)
an options parser for environment variable configuration
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.
Utility loading and managing tap configuration
Gracefully reload your modules when they change. Only works with CJS, not ESM. Uses stat polling.
detect when tap output is finished
SDK for using https://tier.run in Node.js applications
A Node.js loader to track processes and which JavaScript files they load.
fast expandable directed acyclic graph using linked lists
RED/USE metrics for express applications (forked to remove vulnerable optional deps)
set of values with pointers to other entries, backed by auto=-expanding UintArray slabs
walk paths fast and efficiently
A userland port of node:lib/internal/per_context/primordials.js
easily create complex multi-column command-line-interfaces
Create 'npm init' packages easily with templates and prompts
Create a tap plugin with 'npm init @tapjs/plugin'
PrismJS syntax highlighting for the terminal
Synchronize the contents of one folder to another location, only copying files if contents differ.
JSON.parse and stringify with better errors that respects formatting
Look up the file that an `import()` statement will resolve to, possibly relative to a given parentURL
a built-in tap extension for t.after() and t.teardown()
a built-in tap extension for t.afterEach()
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.
a built-in tap extension for t.before()
a built-in tap extension for t.beforeEach()
pluggable core of node-tap
Alternative to @tapjs/typescript. Load typescript using @esbuild-kit/cjs-loader and @esbuild-kit/esm-loader instead of ts-node.
tap plugin providing t.only() and grep option
Tap plugin to provide t.testdir() and t.fixture()
a built-in tap extension for t.intercept() and t.capture()
tap plugin adding t.mockRequire() and t.mockImport()
Pretty test output reporters for tap
Command-line interface for the node-tap runner
a sinon extension for tap
A default tap plugin that adds snapshot functionality.
a built-in tap extension for t.spawn()
Utility for working with stack traces
a built-in tap extension for t.stdin()
the pluggable Test class for node-tap
a built-in tap extension that adds typescript support
a built-in tap extension for t.worker()
placeholder package for the bundled @tapjs/test dependency
Verify if something is a Promise
a make believe clock for tests involving time
extend the @tapjs/asserts methods with various aliases
An optional plugin adding Mocha-like BDD and TDD interfaces to the global environment when tap is loaded.
TypeScript execution environment and REPL for node.js, with source map support
TypeScript HYbridizer - Hybrid (CommonJS/ESM) TypeScript node package builder
A copy of @tapjs/dummy-plugin, but with a different name
Stream TAP test data as a serialized node:test stream
Port of node's error_serdes.js to userland, plus test message streaming
convert string with ANSI color codes into a styled html pre tag
Simple lightweight performance sampler
Do the `postMessage()`/`on('message')` thing with any arbitrary socket (really, any stream) in Node.js.
A utility for creating a daemon process that listens on a socket, and a client that talks to it.
Call a function and catch any errors it throws
Cache a function that takes a path as an argument, expiring whenever the file mtime changes
A TypeScript IMPort loader for Node.js
Alternative to @tapjs/typescript. Load typescript using tsx instead of ts-node.
fs read and write streams based on minipass
Walk any kind of tree structure depth- or breadth-first. Supports promises and advanced map-reduce operations with a very small API.
Contain async insanity so that the dark pony lord doesn't eat souls
fs read and write streams based on minipass
Add callbacks to requests in flight to avoid async duplication
minimal implementation of a PassThrough stream
A small fast zlib stream built on [minipass](http://npm.im/minipass) and Node.js's zlib binding.
A flow control lib small enough to fit on in a slide presentation. Derived live at Oak.JS
Load the local package.json from either src or dist folder
Run operations on a graph, maximizing parallelism
a built-in tap extension for t.chdir()
Match balanced character pairs, like "{" and "}"
Brace expansion as known from sh/bash
A better Buffer.toString()
An extremely tiny LRU cache
the command line bin script that used to be in node-glob
Convert a NODE_OPTIONS environment variable to an argv list, or vice versa
Like which(1) unix command. Find the first instance of an executable in the PATH.
This is a way to track the results of a promise, without obscuring `unhandledrejection` events, or losing other added properties that may exist on the promise being tracked.
A bit of JavaScript to create the [Gravitationism](https://blog.izs.me/2025/10/church-of-gravitationism/) [Solar](https://izs.me/solar-events.ics) and [Lunar](https://izs.me/months.ics) calendars.